批量操作

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│ 1. 进入批量模式  │ -> │ 2. 选择用户/Key │ -> │ 3. 配置更新字段 │
└─────────────────┘    └─────────────────┘    └─────────────────┘
                                                        │
┌─────────────────┐    ┌─────────────────┐    ┌────────▼────────┐
│ 6. 完成更新      │ <- │ 5. 执行批量更新  │ <- │ 4. 确认变更内容 │
└─────────────────┘    └─────────────────┘    └─────────────────┘

export const UpdateUserSchema = z.object({
  note: z.string().max(200).optional(),
  tags: z.array(z.string().max(32)).max(20).optional(),
  rpm: z.number().min(0).max(1_000_000).nullable().optional(),
  dailyQuota: z.number().min(0).max(100_000).nullable().optional(),
  limit5hUsd: z.number().min(0).max(10_000).nullable().optional(),
  limitWeeklyUsd: z.number().min(0).max(50_000).nullable().optional(),
  limitMonthlyUsd: z.number().min(0).max(200_000).nullable().optional(),
});

export const UpdateKeySchema = z.object({
  providerGroup: z.string().max(200).nullable().optional(),
  limit5hUsd: z.number().min(0).max(10_000).nullable().optional(),
  limitDailyUsd: z.number().min(0).max(10_000).nullable().optional(),
  limitWeeklyUsd: z.number().min(0).max(50_000).nullable().optional(),
  limitMonthlyUsd: z.number().min(0).max(200_000).nullable().optional(),
  canLoginWebUi: z.boolean().optional(),
  isEnabled: z.boolean().optional(),
});

// 用户批量更新限制
const MAX_BATCH_SIZE = 500;

// Key 批量更新限制
const MAX_BATCH_SIZE = 500;

export interface BatchUpdateUsersParams {
  userIds: number[];
  updates: {
    note?: string;
    tags?: string[];
    rpm?: number | null;
    dailyQuota?: number | null;
    limit5hUsd?: number | null;
    limitWeeklyUsd?: number | null;
    limitMonthlyUsd?: number | null;
  };
}

export interface BatchUpdateResult {
  requestedCount: number;  // 请求更新的数量
  updatedCount: number;    // 实际更新的数量
  updatedIds: number[];    // 已更新的用户 ID 列表
}

import { batchUpdateUsers } from "@/actions/users";

const result = await batchUpdateUsers({
  userIds: [1, 2, 3, 4, 5],
  updates: {
    tags: ["premium", "team-a"],
    rpm: 120,
    dailyQuota: 50.00,
    limitMonthlyUsd: 500.00
  }
});

if (result.ok) {
  console.log(`Updated ${result.data.updatedCount} users`);
  console.log(`Updated user IDs: ${result.data.updatedIds.join(", ")}`);
} else {
  console.error(`Batch update failed: ${result.error}`);
}

export interface BatchUpdateKeysParams {
  keyIds: number[];
  updates: {
    providerGroup?: string | null;
    limit5hUsd?: number | null;
    limitDailyUsd?: number | null;
    limitWeeklyUsd?: number | null;
    limitMonthlyUsd?: number | null;
    canLoginWebUi?: boolean;
    isEnabled?: boolean;
  };
}

import { batchUpdateKeys } from "@/actions/keys";

const result = await batchUpdateKeys({
  keyIds: [10, 11, 12, 13, 14],
  updates: {
    providerGroup: "production",
    canLoginWebUi: true,
    limitDailyUsd: 25.00
  }
});

if (result.ok) {
  console.log(`Updated ${result.data.updatedCount} keys`);
} else {
  console.error(`Batch update failed: ${result.error}`);
}

type ActionResult<T = undefined> =
  | { ok: true; data?: T }
  | { ok: false; error: string; errorCode?: string; errorParams?: Record<string, string | number> };

const result = await batchUpdateUsers({ userIds: [1, 2, 3], updates: { rpm: 100 } });

if (!result.ok) {
  switch (result.errorCode) {
    case "BATCH_SIZE_EXCEEDED":
      console.error("批量大小超过限制，请减少选择的数量");
      break;
    case "PERMISSION_DENIED":
      console.error("权限不足，需要管理员权限");
      break;
    case "CANNOT_DISABLE_LAST_KEY":
      console.error("不能禁用用户的最后一个 Key");
      break;
    default:
      console.error(`操作失败: ${result.error}`);
  }
}

export interface GetUsersBatchParams {
  cursor?: number;      // 分页游标
  limit?: number;       // 每页数量
  searchTerm?: string;  // 搜索关键词
  tagFilters?: string[];        // 标签过滤
  keyGroupFilters?: string[];   // Key 分组过滤
  statusFilter?: "all" | "active" | "expired" | 
                   "expiringSoon" | "enabled" | "disabled";
  sortBy?: "name" | "tags" | "expiresAt" | "rpm" | 
            "limit5hUsd" | "limitDailyUsd" | 
            "limitWeeklyUsd" | "limitMonthlyUsd" | "createdAt";
  sortOrder?: "asc" | "desc";
}

export interface GetUsersBatchResult {
  users: UserDisplay[];
  nextCursor: number | null;
  hasMore: boolean;
}

import { getUsersBatch } from "@/actions/users";

const result = await getUsersBatch({
  cursor: 0,
  limit: 50,
  searchTerm: "team-a",
  tagFilters: ["premium"],
  statusFilter: "active",
  sortBy: "createdAt",
  sortOrder: "desc"
});

if (result.ok) {
  console.log(`Retrieved ${result.data.users.length} users`);
  console.log(`Has more: ${result.data.hasMore}`);
  console.log(`Next cursor: ${result.data.nextCursor}`);
}

interface BatchEditDialogProps {
  open: boolean;                    // 对话框显示状态
  onOpenChange: (open: boolean) => void;
  selectedUserIds: Set<number>;     // 选中的用户 ID 集合
  selectedKeyIds: Set<number>;      // 选中的 Key ID 集合
  onSuccess?: () => void;           // 成功回调
}

interface FieldCardProps {
  title: string;           // 字段标题
  description?: string;    // 字段说明
  enabled: boolean;        // 是否启用
  onEnabledChange: (enabled: boolean) => void;
  children: React.ReactNode;  // 输入控件
}

const hasAnyUpdate = Object.values(updates).some((v) => v !== undefined);
if (!hasAnyUpdate) {
  return { 
    ok: false, 
    error: tError("EMPTY_UPDATE"), 
    errorCode: ERROR_CODES.EMPTY_UPDATE 
  };
}

await db.transaction(async (tx) => {
  const existingRows = await tx
    .select({ id: usersTable.id })
    .from(usersTable)
    .where(and(
      inArray(usersTable.id, requestedIds), 
      isNull(usersTable.deletedAt)
    ));

  const existingSet = new Set(existingRows.map((r) => r.id));
  const missingIds = requestedIds.filter((id) => !existingSet.has(id));
  
  if (missingIds.length > 0) {
    throw new BatchUpdateError(
      `部分用户不存在: ${missingIds.join(", ")}`,
      ERROR_CODES.NOT_FOUND
    );
  }
});

// 更新前检查
if (updates.isEnabled === false) {
  const currentKeyStates = await tx
    .select({ id: keysTable.id, userId: keysTable.userId, 
              isEnabled: keysTable.isEnabled })
    .from(keysTable)
    .where(and(
      inArray(keysTable.id, requestedIds), 
      isNull(keysTable.deletedAt)
    ));

  // 统计每个用户将被禁用的 Key 数量
  const userDisableCounts = new Map<number, number>();
  for (const key of currentKeyStates) {
    if (key.isEnabled) {
      userDisableCounts.set(
        key.userId, 
        (userDisableCounts.get(key.userId) ?? 0) + 1
      );
    }
  }

  // 确保每个用户至少保留一个启用的 Key
  for (const [userId, disableCount] of userDisableCounts) {
    const currentEnabledCount = userEnabledCounts.get(userId) ?? 0;
    if (currentEnabledCount - disableCount < 1) {
      throw new BatchUpdateError(
        tError("CANNOT_DISABLE_LAST_KEY"), 
        ERROR_CODES.OPERATION_FAILED
      );
    }
  }
}

await db.transaction(async (tx) => {
  // 事务内的所有操作都是原子的
  // 如果抛出任何错误，所有变更都会被回滚
});

if (updatedIds.length !== requestedIds.length) {
  throw new BatchUpdateError(
    "批量更新失败：更新行数不匹配", 
    ERROR_CODES.UPDATE_FAILED
  );
}

if (anySuccess) {
  // 刷新相关查询缓存
  await queryClient.invalidateQueries({ queryKey: ["users"] });
  await queryClient.invalidateQueries({ queryKey: ["userKeyGroups"] });
  await queryClient.invalidateQueries({ queryKey: ["userTags"] });
}

// 只有完全成功时才关闭对话框
if (anySuccess && !anyFailed) {
  onSuccess?.();
  handleRequestClose(false);
} else {
  // 关闭确认对话框，但保持主对话框打开以便重试
  setConfirmOpen(false);
}

const requestedIds = Array.from(new Set(params.userIds))
  .filter((id) => Number.isInteger(id));

if (updates.dailyQuota !== undefined) {
  dbUpdates.dailyLimitUsd = updates.dailyQuota === null 
    ? null 
    : updates.dailyQuota.toString();
}

// 第一步：获取团队用户
const teamUsers = await getUsersBatch({
  searchTerm: "team-alpha",
  limit: 50
});

if (!teamUsers.ok) {
  console.error("Failed to fetch users");
  return;
}

const userIds = teamUsers.data.users.map(u => u.id);

// 第二步：批量应用配置
const result = await batchUpdateUsers({
  userIds,
  updates: {
    tags: ["team-alpha", "engineering"],
    rpm: 200,
    dailyQuota: 100.00,
    limitWeeklyUsd: 500.00,
    limitMonthlyUsd: 2000.00
  }
});

if (result.ok) {
  console.log(`Successfully configured ${result.data.updatedCount} team members`);
}

// 获取 staging 环境的所有 Key
const stagingKeys = await getUsersBatch({
  tagFilters: ["staging"],
  limit: 500
});

// 收集所有 Key ID
const keyIds: number[] = [];
for (const user of stagingKeys.data?.users || []) {
  // 假设每个用户的 keys 数组包含 Key 信息
  keyIds.push(...user.keys.map(k => k.id));
}

// 批量更新供应商分组
const result = await batchUpdateKeys({
  keyIds,
  updates: {
    providerGroup: "production",
    limitDailyUsd: 50.00  // 生产环境设置更严格的限额
  }
});

// 为所有 premium 用户临时提升配额
const premiumUsers = await getUsersBatch({
  tagFilters: ["premium"],
  statusFilter: "active",
  limit: 500
});

if (premiumUsers.ok) {
  const userIds = premiumUsers.data.users.map(u => u.id);

  await batchUpdateUsers({
    userIds,
    updates: {
      rpm: 500,  // 从默认 120 提升到 500
      limit5hUsd: 100.00  // 同时提升短期限额
    }
  });
}

// 高峰期过后恢复默认设置
// ... 类似的批量更新代码

// 为所有带有 "legacy-project" 标签的用户移除该标签
const legacyUsers = await getUsersBatch({
  tagFilters: ["legacy-project"],
  limit: 500
});

if (legacyUsers.ok) {
  for (const user of legacyUsers.data.users) {
    // 过滤掉 legacy-project 标签，保留其他标签
    const newTags = user.tags.filter(t => t !== "legacy-project");

    await batchUpdateUsers({
      userIds: [user.id],
      updates: { tags: newTags }
    });
  }
}

// 自动刷新的查询缓存
await queryClient.invalidateQueries({ queryKey: ["users"] });
await queryClient.invalidateQueries({ queryKey: ["userKeyGroups"] });
await queryClient.invalidateQueries({ queryKey: ["userTags"] });

// 在调用批量更新前记录操作日志
async function auditedBatchUpdate(
  adminId: number,
  params: BatchUpdateUsersParams
) {
  // 记录操作开始
  await logAuditEvent({
    adminId,
    action: "BATCH_UPDATE_USERS",
    targetCount: params.userIds.length,
    updates: Object.keys(params.updates),
    timestamp: new Date()
  });

  const result = await batchUpdateUsers(params);

  // 记录操作结果
  await logAuditEvent({
    adminId,
    action: "BATCH_UPDATE_USERS_COMPLETE",
    success: result.ok,
    updatedCount: result.ok ? result.data.updatedCount : 0,
    error: result.ok ? undefined : result.error
  });

  return result;
}

// 强制刷新缓存
await queryClient.invalidateQueries({
  queryKey: ["users"],
  exact: false  // 刷新所有匹配的查询
});

开始事务
  ├── 验证所有条目存在
  ├── 执行业务规则检查
  ├── 更新数据库记录
  └── 验证更新结果
提交/回滚事务

await db.transaction(async (tx) => {
  // 使用 SELECT FOR UPDATE 锁定行
  const existingRows = await tx
    .select({ id: usersTable.id })
    .from(usersTable)
    .where(inArray(usersTable.id, requestedIds))
    .for('update');  // 行级锁定
  
  // 执行更新...
});

.where(and(
  inArray(usersTable.id, requestedIds),
  isNull(usersTable.deletedAt)  // 排除已删除的记录
))