0.0.1.2

app/api/trees/[treeId]/activity-logs/route.ts

@@ -3,6 +3,7 @@ import { getServerSession } from "next-auth"
 import { authOptions } from "@/lib/auth"
 import { prisma } from "@/lib/prisma"
 import { checkPermission } from "@/lib/permissions"
+import { Role } from "@prisma/client"
 
 // 获取家族树的活动日志
 export async function GET(
@@ -20,10 +21,10 @@ export async function GET(
     const { searchParams } = new URL(req.url)
     const limit = parseInt(searchParams.get('limit') || '50')
 
-    // 检查权限
+    // 检查权限（所有有权限访问该家族树的人都能查看操作日志）
     const { hasPermission } = await checkPermission(session.user.id, treeId)
     if (!hasPermission) {
-      return NextResponse.json({ error: "无权访问此家族树" }, { status: 403 })
+      return NextResponse.json({ error: "无权访问此家族树的操作日志" }, { status: 403 })
     }
 
     const logs = await prisma.activityLog.findMany({
@@ -50,3 +51,42 @@ export async function GET(
     )
   }
 }
+
+// 清空家族树的活动日志
+export async function DELETE(
+  req: NextRequest,
+  { params }: { params: Promise<{ treeId: string }> }
+) {
+  try {
+    const session = await getServerSession(authOptions)
+    
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: "未授权" }, { status: 401 })
+    }
+
+    const { treeId } = await params
+
+    // 检查权限（需要 OWNER 权限才能清空日志）
+    const { hasPermission, role } = await checkPermission(session.user.id, treeId, Role.OWNER)
+    if (!hasPermission || role !== Role.OWNER) {
+      return NextResponse.json({ error: "只有家族树所有者才能清空操作日志" }, { status: 403 })
+    }
+
+    // 删除该家族树的所有日志
+    const result = await prisma.activityLog.deleteMany({
+      where: { treeId }
+    })
+
+    return NextResponse.json({ 
+      success: true, 
+      deletedCount: result.count,
+      message: `已清空 ${result.count} 条操作日志` 
+    })
+  } catch (error) {
+    console.error("清空活动日志失败:", error)
+    return NextResponse.json(
+      { error: "清空活动日志失败" },
+      { status: 500 }
+    )
+  }
+}

app/api/trees/[treeId]/collaborators/route.ts

@@ -0,0 +1,123 @@
+import { NextRequest, NextResponse } from "next/server"
+import { getServerSession } from "next-auth"
+import { authOptions } from "@/lib/auth"
+import { prisma } from "@/lib/prisma"
+
+// 获取协作者列表
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ treeId: string }> }
+) {
+  try {
+    const session = await getServerSession(authOptions)
+    
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: "未授权" }, { status: 401 })
+    }
+
+    const { treeId } = await params
+
+    // 检查权限（所有者或协作者都可以看）
+    const tree = await prisma.familyTree.findFirst({
+      where: {
+        id: treeId,
+        OR: [
+          { ownerId: session.user.id },
+          {
+            collaborators: {
+              some: {
+                userId: session.user.id
+              }
+            }
+          }
+        ]
+      }
+    })
+
+    if (!tree) {
+      return NextResponse.json({ error: "家族树不存在或无权访问" }, { status: 404 })
+    }
+
+    // 获取协作者
+    const collaborators = await prisma.treeCollaborator.findMany({
+      where: { treeId },
+      include: {
+        user: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+            avatar: true
+          }
+        }
+      },
+      orderBy: {
+        invitedAt: 'desc'
+      }
+    })
+
+    return NextResponse.json({ collaborators })
+  } catch (error) {
+    console.error("获取协作者失败:", error)
+    return NextResponse.json(
+      { error: "获取协作者失败" },
+      { status: 500 }
+    )
+  }
+}
+
+// 移除协作者
+export async function DELETE(
+  req: NextRequest,
+  { params }: { params: Promise<{ treeId: string }> }
+) {
+  try {
+    const session = await getServerSession(authOptions)
+    
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: "未授权" }, { status: 401 })
+    }
+
+    const { treeId } = await params
+    const { searchParams } = new URL(req.url)
+    const userId = searchParams.get('userId')
+
+    if (!userId) {
+      return NextResponse.json({ error: "缺少用户ID" }, { status: 400 })
+    }
+
+    // 检查权限：只有所有者可以移除协作者，或者是协作者自己退出
+    const tree = await prisma.familyTree.findFirst({
+      where: {
+        id: treeId
+      }
+    })
+
+    if (!tree) {
+      return NextResponse.json({ error: "家族树不存在" }, { status: 404 })
+    }
+
+    const isOwner = tree.ownerId === session.user.id
+    const isSelf = userId === session.user.id
+
+    if (!isOwner && !isSelf) {
+      return NextResponse.json({ error: "无权移除此协作者" }, { status: 403 })
+    }
+
+    // 移除协作者
+    await prisma.treeCollaborator.deleteMany({
+      where: {
+        treeId,
+        userId
+      }
+    })
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    console.error("移除协作者失败:", error)
+    return NextResponse.json(
+      { error: "移除协作者失败" },
+      { status: 500 }
+    )
+  }
+}

app/api/trees/[treeId]/invite/route.ts

@@ -0,0 +1,139 @@
+import { NextRequest, NextResponse } from "next/server"
+import { getServerSession } from "next-auth"
+import { authOptions } from "@/lib/auth"
+import { prisma } from "@/lib/prisma"
+import { hash } from "bcryptjs"
+import { z } from "zod"
+import { sendInvitationEmail } from "@/lib/mail"
+
+const inviteSchema = z.object({
+  email: z.string().email("请输入有效的邮箱地址"),
+  role: z.enum(["EDITOR", "VIEWER"], {
+    errorMap: () => ({ message: "请选择有效的角色" }),
+  }),
+  password: z.string().min(6, "密码至少需要6位").optional(),
+})
+
+// 邀请协作者
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ treeId: string }> }
+) {
+  try {
+    const session = await getServerSession(authOptions)
+    
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: "未授权" }, { status: 401 })
+    }
+
+    const { treeId } = await params
+    const body = await req.json()
+    const { email, role, password } = inviteSchema.parse(body)
+
+    // 1. 检查权限
+    const tree = await prisma.familyTree.findFirst({
+      where: {
+        id: treeId,
+        ownerId: session.user.id
+      }
+    })
+
+    if (!tree) {
+      return NextResponse.json({ error: "家族树不存在或无权邀请" }, { status: 404 })
+    }
+
+    // 2. 检查目标用户是否存在
+    let user = await prisma.user.findUnique({
+      where: { email }
+    })
+
+    let isNewUser = false
+
+    // 3. 如果用户不存在，创建新用户
+    if (!user) {
+      if (!password) {
+        return NextResponse.json({ error: "新用户必须设置初始密码" }, { status: 400 })
+      }
+
+      const hashedPassword = await hash(password, 12)
+      
+      user = await prisma.user.create({
+        data: {
+          email,
+          password: hashedPassword,
+          name: email.split('@')[0], // 使用邮箱前缀作为默认用户名
+        }
+      })
+      isNewUser = true
+    }
+
+    // 4. 检查是否已经是协作者或所有者
+    if (user.id === tree.ownerId) {
+      return NextResponse.json({ error: "不能邀请自己" }, { status: 400 })
+    }
+
+    const existingCollaborator = await prisma.treeCollaborator.findUnique({
+      where: {
+        treeId_userId: {
+          treeId,
+          userId: user.id
+        }
+      }
+    })
+
+    if (existingCollaborator) {
+      // 如果已存在，更新角色
+      await prisma.treeCollaborator.update({
+        where: { id: existingCollaborator.id },
+        data: { role }
+      })
+      return NextResponse.json({ 
+        message: "用户已是协作者，角色已更新",
+        isNewUser: false
+      })
+    }
+
+    // 5. 添加协作者
+    await prisma.treeCollaborator.create({
+      data: {
+        treeId,
+        userId: user.id,
+        role,
+        invitedBy: session.user.id
+      }
+    })
+
+    // 6. 发送邀请邮件
+    try {
+      await sendInvitationEmail(
+        email,
+        session.user.name || session.user.email || "用户",
+        tree.name,
+        role,
+        isNewUser ? password : undefined
+      )
+    } catch (emailError) {
+      console.error("发送邀请邮件失败:", emailError)
+      // 邮件发送失败不影响邀请结果，但记录日志
+    }
+
+    return NextResponse.json({ 
+      message: isNewUser ? "新用户已创建并添加为协作者，邮件已发送" : "用户已添加为协作者，邮件已发送",
+      isNewUser
+    }, { status: 201 })
+
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: error.errors[0].message },
+        { status: 400 }
+      )
+    }
+    
+    console.error("邀请协作者失败:", error)
+    return NextResponse.json(
+      { error: "邀请协作者失败" },
+      { status: 500 }
+    )
+  }
+}

app/api/trees/[treeId]/members/route.ts

@@ -68,6 +68,14 @@ export async function GET(
       }
     }
 
+    console.log('👥 GET /api/trees/[treeId]/members 返回数据:', {
+      treeId,
+      userId: session.user.id,
+      membersCount: members.length,
+      rootId,
+      members: members.map(m => ({ id: m.id, fullName: m.fullName, generation: m.generation }))
+    })
+
     return NextResponse.json({ members, rootId })
   } catch (error) {
     console.error("获取成员失败:", error)

app/api/trees/[treeId]/route.ts

@@ -52,7 +52,34 @@ export async function GET(
       return NextResponse.json({ error: "家族树不存在或无权访问" }, { status: 404 })
     }
 
-    return NextResponse.json({ tree })
+    // 计算当前用户角色
+    let currentUserRole = "VIEWER"
+    if (tree.ownerId === session.user.id) {
+      currentUserRole = "OWNER"
+    } else {
+      const collaborator = await prisma.treeCollaborator.findUnique({
+        where: {
+          treeId_userId: {
+            treeId: tree.id,
+            userId: session.user.id
+          }
+        }
+      })
+      if (collaborator) {
+        currentUserRole = collaborator.role
+      }
+    }
+
+    console.log('🌳 GET /api/trees/[treeId] 返回数据:', {
+      treeId,
+      userId: session.user.id,
+      treeName: tree.name,
+      currentUserRole,
+      membersCount: tree._count.members,
+      collaboratorsCount: tree._count.collaborators
+    })
+
+    return NextResponse.json({ tree: { ...tree, currentUserRole } })
   } catch (error) {
     console.error("获取家族树失败:", error)
     return NextResponse.json(

app/api/trees/route.ts

@@ -18,37 +18,58 @@ export async function GET(req: NextRequest) {
       return NextResponse.json({ error: "未授权" }, { status: 401 })
     }
 
-    const trees = await prisma.familyTree.findMany({
-      where: {
-        OR: [
-          { ownerId: session.user.id },
-          {
-            collaborators: {
-              some: {
-                userId: session.user.id
-              }
-            }
-          }
-        ]
-      },
+    // 1. 查询拥有的家族树
+    const ownedTrees = await prisma.familyTree.findMany({
+      where: { ownerId: session.user.id },
       include: {
         owner: {
-          select: {
-            id: true,
-            name: true,
-            email: true,
-          }
+          select: { id: true, name: true, email: true }
         },
         _count: {
-          select: {
-            members: true,
-            collaborators: true,
+          select: { members: true, collaborators: true }
+        }
+      },
+      orderBy: { updatedAt: 'desc' }
+    })
+
+    // 2. 查询协作的家族树
+    const collaboratedRelations = await prisma.treeCollaborator.findMany({
+      where: { userId: session.user.id },
+      include: {
+        tree: {
+          include: {
+            owner: {
+              select: { id: true, name: true, email: true }
+            },
+            _count: {
+              select: { members: true, collaborators: true }
+            }
           }
         }
       },
-      orderBy: {
-        updatedAt: 'desc'
-      }
+      orderBy: { invitedAt: 'desc' }
+    })
+
+    // 3. 格式化数据
+    const formattedOwnedTrees = ownedTrees.map(tree => ({
+      ...tree,
+      currentUserRole: "OWNER"
+    }))
+
+    const formattedCollaboratedTrees = collaboratedRelations.map(relation => ({
+      ...relation.tree,
+      currentUserRole: relation.role
+    }))
+
+    // 4. 合并列表
+    const trees = [...formattedOwnedTrees, ...formattedCollaboratedTrees]
+
+    console.log('🌳 GET /api/trees 返回数据:', {
+      userId: session.user.id,
+      ownedCount: formattedOwnedTrees.length,
+      collaboratedCount: formattedCollaboratedTrees.length,
+      totalCount: trees.length,
+      trees: trees.map(t => ({ id: t.id, name: t.name, role: t.currentUserRole }))
     })
 
     return NextResponse.json({ trees })