create-nextdevtpl 2.6.0

package/template/src/features/subscription/manifest.ts

@@ -0,0 +1,13 @@
+import { defineModule } from "@/core/modules";
+
+export const subscriptionModule = defineModule({
+  id: "subscription",
+  name: "Subscription",
+  description: "订阅状态、计划识别和权益计算",
+  kind: "optional",
+  dependencies: [],
+  routes: [],
+  navigation: [],
+  translations: ["Subscription"],
+  schema: ["subscription"],
+});

package/template/src/features/subscription/services/user-plan.ts

@@ -0,0 +1,181 @@
+/**
+ * 用户订阅计划服务
+ *
+ * 提供获取用户当前计划和检查特权的功能
+ */
+
+import { eq } from "drizzle-orm";
+import {
+  formatFileSizeLimit,
+  getPlanFromPriceId,
+  getPlanPrivileges,
+  getUpgradeMessage,
+  isWithinFileSizeLimit,
+  type SubscriptionPlan,
+} from "@/config/subscription-plan";
+import { db } from "@/db";
+import { subscription } from "@/db/schema/subscription";
+
+// ============================================
+// 类型定义
+// ============================================
+
+/**
+ * 用户计划信息
+ */
+export interface UserPlanInfo {
+  /** 当前计划 */
+  plan: SubscriptionPlan;
+  /** 计划名称 */
+  planName: string;
+  /** 是否有活跃订阅 */
+  hasActiveSubscription: boolean;
+  /** 订阅状态 */
+  subscriptionStatus: string | null;
+  /** 当前周期结束时间（续期日期） */
+  currentPeriodEnd: Date | null;
+  /** 价格 ID（用于查找价格信息） */
+  priceId: string | null;
+  /** 是否在周期结束时取消 */
+  cancelAtPeriodEnd: boolean;
+}
+
+/**
+ * 特权检查结果
+ */
+export interface PrivilegeCheckResult {
+  /** 是否允许 */
+  allowed: boolean;
+  /** 错误消息（如果不允许） */
+  errorMessage?: string;
+  /** 升级建议（如果不允许） */
+  upgradeMessage?: string;
+}
+
+// ============================================
+// 核心服务函数
+// ============================================
+
+/**
+ * 获取用户当前订阅计划
+ *
+ * 从 subscription 表查询 priceId 并映射到计划类型
+ * 如果没有活跃订阅，返回 "free"
+ *
+ * @param userId - 用户 ID
+ * @returns 用户计划信息
+ */
+export async function getUserPlan(userId: string): Promise<UserPlanInfo> {
+  // 查询用户的活跃订阅
+  const [userSubscription] = await db
+    .select({
+      priceId: subscription.priceId,
+      status: subscription.status,
+      currentPeriodEnd: subscription.currentPeriodEnd,
+      cancelAtPeriodEnd: subscription.cancelAtPeriodEnd,
+    })
+    .from(subscription)
+    .where(eq(subscription.userId, userId))
+    .limit(1);
+
+  // 检查订阅是否有效
+  const isCanceledButStillActive =
+    userSubscription?.status === "canceled" &&
+    userSubscription.currentPeriodEnd &&
+    new Date(userSubscription.currentPeriodEnd) > new Date();
+
+  const isActive =
+    userSubscription &&
+    (["active", "trialing", "lifetime"].includes(userSubscription.status) ||
+      isCanceledButStillActive);
+
+  if (!isActive || !userSubscription) {
+    return {
+      plan: "free",
+      planName: "Free",
+      hasActiveSubscription: false,
+      subscriptionStatus: userSubscription?.status ?? null,
+      currentPeriodEnd: null,
+      priceId: null,
+      cancelAtPeriodEnd: false,
+    };
+  }
+
+  // 判断是否处于"已取消待到期"状态
+  const effectiveCancelAtPeriodEnd =
+    isCanceledButStillActive || userSubscription.cancelAtPeriodEnd;
+
+  // 从 priceId 映射到计划
+  const plan = getPlanFromPriceId(userSubscription.priceId);
+
+  if (!plan) {
+    console.warn(
+      `Unknown priceId: ${userSubscription.priceId} for user ${userId}`
+    );
+    return {
+      plan: "free",
+      planName: "Free",
+      hasActiveSubscription: true,
+      subscriptionStatus: userSubscription.status,
+      currentPeriodEnd: userSubscription.currentPeriodEnd,
+      priceId: userSubscription.priceId,
+      cancelAtPeriodEnd: effectiveCancelAtPeriodEnd,
+    };
+  }
+
+  const privileges = getPlanPrivileges(plan);
+
+  return {
+    plan,
+    planName: privileges.name,
+    hasActiveSubscription: true,
+    subscriptionStatus: userSubscription.status,
+    currentPeriodEnd: userSubscription.currentPeriodEnd,
+    priceId: userSubscription.priceId,
+    cancelAtPeriodEnd: effectiveCancelAtPeriodEnd,
+  };
+}
+
+/**
+ * 获取用户计划类型（简化版，仅返回计划类型）
+ *
+ * @param userId - 用户 ID
+ * @returns 计划类型
+ */
+export async function getUserPlanType(
+  userId: string
+): Promise<SubscriptionPlan> {
+  const { plan } = await getUserPlan(userId);
+  return plan;
+}
+
+// ============================================
+// 特权检查函数
+// ============================================
+
+/**
+ * 检查文件大小是否在用户计划限制内
+ *
+ * @param userId - 用户 ID
+ * @param fileSizeBytes - 文件大小（字节）
+ * @returns 检查结果
+ */
+export async function checkFileSizePrivilege(
+  userId: string,
+  fileSizeBytes: number
+): Promise<PrivilegeCheckResult> {
+  const { plan } = await getUserPlan(userId);
+
+  if (isWithinFileSizeLimit(plan, fileSizeBytes)) {
+    return { allowed: true };
+  }
+
+  const limit = formatFileSizeLimit(plan);
+  const actualSize = `${(fileSizeBytes / (1024 * 1024)).toFixed(1)}MB`;
+
+  return {
+    allowed: false,
+    errorMessage: `File size (${actualSize}) exceeds ${limit} limit for your plan.`,
+    upgradeMessage: getUpgradeMessage(plan, `Files over ${limit}`),
+  };
+}

package/template/src/features/support/actions/admin-ticket.ts

@@ -0,0 +1,172 @@
+"use server";
+
+import { desc, eq } from "drizzle-orm";
+import { revalidatePath } from "next/cache";
+
+import { db } from "@/db";
+import { user } from "@/db/schema/auth";
+import { ticket, ticketMessage } from "@/db/schema/support";
+import {
+  addTicketMessageSchema,
+  updateTicketStatusSchema,
+} from "@/features/support/schemas";
+import { adminAction } from "@/lib/safe-action";
+
+const withAdminTicketAction = (name: string) =>
+  adminAction.metadata({ action: `support.admin.${name}` });
+
+/**
+ * 获取所有工单列表 (管理员)
+ */
+export const getAllTicketsAction = withAdminTicketAction(
+  "getAllTickets"
+).action(async () => {
+  const tickets = await db
+    .select({
+      id: ticket.id,
+      subject: ticket.subject,
+      category: ticket.category,
+      priority: ticket.priority,
+      status: ticket.status,
+      createdAt: ticket.createdAt,
+      updatedAt: ticket.updatedAt,
+      user: {
+        id: user.id,
+        name: user.name,
+        email: user.email,
+        image: user.image,
+      },
+    })
+    .from(ticket)
+    .leftJoin(user, eq(ticket.userId, user.id))
+    .orderBy(desc(ticket.createdAt));
+
+  return { tickets };
+});
+
+/**
+ * 获取工单详情 (管理员)
+ */
+export const getAdminTicketDetailAction = withAdminTicketAction(
+  "getAdminTicketDetail"
+)
+  .schema(addTicketMessageSchema.pick({ ticketId: true }))
+  .action(async ({ parsedInput: { ticketId } }) => {
+    const ticketResult = await db
+      .select({
+        ticket: ticket,
+        user: {
+          id: user.id,
+          name: user.name,
+          email: user.email,
+          image: user.image,
+        },
+      })
+      .from(ticket)
+      .leftJoin(user, eq(ticket.userId, user.id))
+      .where(eq(ticket.id, ticketId))
+      .limit(1);
+
+    const result = ticketResult[0];
+    if (!result) {
+      throw new Error("工单不存在");
+    }
+
+    const messages = await db
+      .select({
+        id: ticketMessage.id,
+        content: ticketMessage.content,
+        isAdminResponse: ticketMessage.isAdminResponse,
+        createdAt: ticketMessage.createdAt,
+        user: {
+          id: user.id,
+          name: user.name,
+          image: user.image,
+        },
+      })
+      .from(ticketMessage)
+      .leftJoin(user, eq(ticketMessage.userId, user.id))
+      .where(eq(ticketMessage.ticketId, ticketId))
+      .orderBy(ticketMessage.createdAt);
+
+    return {
+      ticket: result.ticket,
+      ticketUser: result.user,
+      messages,
+    };
+  });
+
+/**
+ * 管理员回复工单
+ */
+export const adminReplyTicketAction = withAdminTicketAction("replyTicket")
+  .schema(addTicketMessageSchema)
+  .action(async ({ parsedInput: data, ctx }) => {
+    const ticketResult = await db
+      .select()
+      .from(ticket)
+      .where(eq(ticket.id, data.ticketId))
+      .limit(1);
+
+    const ticketData = ticketResult[0];
+    if (!ticketData) {
+      throw new Error("工单不存在");
+    }
+
+    await db.insert(ticketMessage).values({
+      id: crypto.randomUUID(),
+      ticketId: data.ticketId,
+      userId: ctx.userId,
+      content: data.content,
+      isAdminResponse: true,
+    });
+
+    if (ticketData.status === "open") {
+      await db
+        .update(ticket)
+        .set({ status: "in_progress", updatedAt: new Date() })
+        .where(eq(ticket.id, data.ticketId));
+    } else {
+      await db
+        .update(ticket)
+        .set({ updatedAt: new Date() })
+        .where(eq(ticket.id, data.ticketId));
+    }
+
+    revalidatePath(`/admin/tickets/${data.ticketId}`);
+
+    return {
+      message: "回复成功",
+    };
+  });
+
+/**
+ * 更新工单状态 (管理员)
+ */
+export const updateTicketStatusAction = withAdminTicketAction(
+  "updateTicketStatus"
+)
+  .schema(updateTicketStatusSchema)
+  .action(async ({ parsedInput: data }) => {
+    const ticketResult = await db
+      .select()
+      .from(ticket)
+      .where(eq(ticket.id, data.ticketId))
+      .limit(1);
+
+    if (ticketResult.length === 0) {
+      throw new Error("工单不存在");
+    }
+
+    await db
+      .update(ticket)
+      .set({ status: data.status, updatedAt: new Date() })
+      .where(eq(ticket.id, data.ticketId));
+
+    revalidatePath(`/admin/tickets/${data.ticketId}`);
+    revalidatePath("/admin/tickets");
+
+    return {
+      message: "状态更新成功",
+    };
+  });

package/template/src/features/support/actions/admin-users.ts

@@ -0,0 +1,295 @@
+"use server";
+
+import { eq, ilike, or } from "drizzle-orm";
+import { revalidatePath } from "next/cache";
+import { z } from "zod";
+
+import { db } from "@/db";
+import { user } from "@/db/schema/auth";
+import { creditsBalance } from "@/db/schema/credits";
+import { subscription } from "@/db/schema/subscription";
+import { CREDITS_EXPIRY_DAYS, grantCredits } from "@/features/credits";
+import { adminAction } from "@/lib/safe-action";
+
+const withAdminUsersAction = (name: string) =>
+  adminAction.metadata({ action: `support.adminUsers.${name}` });
+
+/**
+ * 更新用户角色 Schema
+ */
+const updateUserRoleSchema = z.object({
+  userId: z.string().min(1, "用户ID不能为空"),
+  role: z.enum(["user", "admin"]),
+});
+
+/**
+ * 封禁/解封用户 Schema
+ */
+const banUserSchema = z.object({
+  userId: z.string().min(1, "用户ID不能为空"),
+  banned: z.boolean(),
+  reason: z.string().optional(),
+});
+
+/**
+ * 手动充值积分 Schema
+ */
+const grantCreditsSchema = z.object({
+  userId: z.string().min(1, "用户ID不能为空"),
+  amount: z
+    .number()
+    .min(1, "积分数量必须大于0")
+    .max(100000, "单次最多充值10万积分"),
+  reason: z.string().min(1, "请填写充值原因").max(200, "原因最多200字符"),
+});
+
+/**
+ * 搜索用户 Schema
+ */
+const searchUsersSchema = z.object({
+  query: z.string().optional(),
+  page: z.number().min(1).default(1),
+  pageSize: z.number().min(1).max(100).default(20),
+});
+
+/**
+ * 获取所有用户列表 (管理员) - 增强版
+ *
+ * 包含积分余额和订阅状态
+ */
+export const getAllUsersAction = withAdminUsersAction("getAllUsers")
+  .schema(searchUsersSchema.optional())
+  .action(async ({ parsedInput }) => {
+    const query = parsedInput?.query;
+
+    // 构建用户选择字段
+    const userSelectFields = {
+      id: user.id,
+      name: user.name,
+      email: user.email,
+      image: user.image,
+      role: user.role,
+      banned: user.banned,
+      bannedReason: user.bannedReason,
+      emailVerified: user.emailVerified,
+      createdAt: user.createdAt,
+    };
+
+    // 根据是否有搜索条件构建查询
+    const users = query?.trim()
+      ? await db
+          .select(userSelectFields)
+          .from(user)
+          .where(
+            or(
+              ilike(user.email, `%${query.trim()}%`),
+              ilike(user.name, `%${query.trim()}%`)
+            )
+          )
+          .orderBy(user.createdAt)
+      : await db.select(userSelectFields).from(user).orderBy(user.createdAt);
+
+    // 获取所有用户的积分余额
+    const balances = await db
+      .select({
+        userId: creditsBalance.userId,
+        balance: creditsBalance.balance,
+        totalEarned: creditsBalance.totalEarned,
+        totalSpent: creditsBalance.totalSpent,
+        status: creditsBalance.status,
+      })
+      .from(creditsBalance);
+
+    // 获取所有用户的订阅状态
+    const subscriptions = await db
+      .select({
+        userId: subscription.userId,
+        status: subscription.status,
+        priceId: subscription.priceId,
+        currentPeriodEnd: subscription.currentPeriodEnd,
+      })
+      .from(subscription);
+
+    // 创建映射
+    const balanceMap = new Map(balances.map((b) => [b.userId, b]));
+    const subscriptionMap = new Map(subscriptions.map((s) => [s.userId, s]));
+
+    // 合并数据
+    const usersWithDetails = users.map((u) => ({
+      ...u,
+      credits: balanceMap.get(u.id) || null,
+      subscription: subscriptionMap.get(u.id) || null,
+    }));
+
+    return { users: usersWithDetails };
+  });
+
+/**
+ * 更新用户角色 (管理员)
+ */
+export const updateUserRoleAction = withAdminUsersAction("updateUserRole")
+  .schema(updateUserRoleSchema)
+  .action(async ({ parsedInput: data, ctx }) => {
+    // 防止管理员更改自己的角色
+    if (data.userId === ctx.userId) {
+      throw new Error("不能更改自己的角色");
+    }
+
+    // 验证用户存在
+    const userResult = await db
+      .select()
+      .from(user)
+      .where(eq(user.id, data.userId))
+      .limit(1);
+
+    if (userResult.length === 0) {
+      throw new Error("用户不存在");
+    }
+
+    // 更新角色
+    await db
+      .update(user)
+      .set({ role: data.role, updatedAt: new Date() })
+      .where(eq(user.id, data.userId));
+
+    // 刷新缓存
+    revalidatePath("/admin/users");
+
+    return {
+      message: `用户角色已更新为 ${data.role === "admin" ? "管理员" : "普通用户"}`,
+    };
+  });
+
+/**
+ * 封禁/解封用户 (管理员)
+ */
+export const banUserAction = withAdminUsersAction("banUser")
+  .schema(banUserSchema)
+  .action(async ({ parsedInput: data, ctx }) => {
+    // 防止管理员封禁自己
+    if (data.userId === ctx.userId) {
+      throw new Error("不能封禁自己");
+    }
+
+    // 验证用户存在
+    const userResult = await db
+      .select()
+      .from(user)
+      .where(eq(user.id, data.userId))
+      .limit(1);
+
+    if (userResult.length === 0) {
+      throw new Error("用户不存在");
+    }
+
+    // 获取目标用户 (经过上面检查，此处一定存在)
+    const targetUser = userResult[0]!;
+
+    // 不能封禁其他管理员
+    if (targetUser.role === "admin" && data.banned) {
+      throw new Error("不能封禁管理员账户");
+    }
+
+    // 更新封禁状态
+    await db
+      .update(user)
+      .set({
+        banned: data.banned,
+        bannedReason: data.banned ? data.reason || null : null,
+        updatedAt: new Date(),
+      })
+      .where(eq(user.id, data.userId));
+
+    // 刷新缓存
+    revalidatePath("/admin/users");
+
+    return {
+      message: data.banned ? "用户已被封禁" : "用户已解除封禁",
+    };
+  });
+
+/**
+ * 手动充值积分 (管理员)
+ */
+export const adminGrantCreditsAction = withAdminUsersAction("grantCredits")
+  .schema(grantCreditsSchema)
+  .action(async ({ parsedInput: data, ctx }) => {
+    // 验证用户存在
+    const userResult = await db
+      .select()
+      .from(user)
+      .where(eq(user.id, data.userId))
+      .limit(1);
+
+    if (userResult.length === 0) {
+      throw new Error("用户不存在");
+    }
+
+    // 计算过期时间
+    const expiresAt = CREDITS_EXPIRY_DAYS
+      ? new Date(Date.now() + CREDITS_EXPIRY_DAYS * 24 * 60 * 60 * 1000)
+      : null;
+
+    // 调用积分系统发放积分
+    const result = await grantCredits({
+      userId: data.userId,
+      amount: data.amount,
+      sourceType: "bonus",
+      debitAccount: `ADMIN:${ctx.userId}`,
+      transactionType: "admin_grant",
+      expiresAt,
+      sourceRef: `admin_grant_${Date.now()}`,
+      description: `管理员充值: ${data.reason}`,
+      metadata: {
+        grantType: "admin_manual",
+        adminId: ctx.userId,
+        reason: data.reason,
+      },
+    });
+
+    // 刷新缓存
+    revalidatePath("/admin/users");
+
+    return {
+      message: `成功为用户充值 ${data.amount} 积分`,
+      newBalance: result.newBalance,
+    };
+  });
+
+/**
+ * 获取单个用户详情 (管理员)
+ */
+export const getUserDetailAction = withAdminUsersAction("getUserDetail")
+  .schema(z.object({ userId: z.string().min(1) }))
+  .action(async ({ parsedInput: { userId } }) => {
+    // 获取用户基本信息
+    const userResult = await db
+      .select()
+      .from(user)
+      .where(eq(user.id, userId))
+      .limit(1);
+
+    if (userResult.length === 0) {
+      throw new Error("用户不存在");
+    }
+
+    // 获取积分余额
+    const balanceResult = await db
+      .select()
+      .from(creditsBalance)
+      .where(eq(creditsBalance.userId, userId))
+      .limit(1);
+
+    // 获取订阅状态
+    const subscriptionResult = await db
+      .select()
+      .from(subscription)
+      .where(eq(subscription.userId, userId))
+      .limit(1);
+
+    return {
+      user: userResult[0],
+      credits: balanceResult[0] || null,
+      subscription: subscriptionResult[0] || null,
+    };
+  });

package/template/src/features/support/actions/index.ts

@@ -0,0 +1,22 @@
+// 工单 Actions 模块导出
+
+// 管理员用户管理 Actions
+export {
+  adminGrantCreditsAction,
+  banUserAction,
+  getAllUsersAction,
+  getUserDetailAction,
+  updateUserRoleAction,
+} from "./admin-users";
+export {
+  addTicketMessageAction,
+  adminReplyTicketAction,
+  // 用户端 Actions
+  createTicketAction,
+  getAdminTicketDetailAction,
+  // 管理员 Actions
+  getAllTicketsAction,
+  getMyTicketsAction,
+  getTicketDetailAction,
+  updateTicketStatusAction,
+} from "./ticket";

package/template/src/features/support/actions/ticket.ts

@@ -0,0 +1,12 @@
+export {
+  adminReplyTicketAction,
+  getAdminTicketDetailAction,
+  getAllTicketsAction,
+  updateTicketStatusAction,
+} from "./admin-ticket";
+export {
+  addTicketMessageAction,
+  createTicketAction,
+  getMyTicketsAction,
+  getTicketDetailAction,
+} from "./user-ticket";