first commit

app/api/dashboard/genealogy/route.ts

@@ -0,0 +1,171 @@
+import { NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+
+interface TeamMember {
+  id: string
+  name: string
+  email: string
+  joinedAt: string
+  totalEarnings: number
+  directReferrals: number
+  level: number
+  children?: TeamMember[]
+}
+
+export async function GET() {
+  try {
+    const session = await auth()
+    
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const userId = session.user.id
+
+    // Build genealogy tree
+    const genealogyTree = await buildGenealogyTree(userId, 0)
+    
+    // Calculate stats
+    const teamSize = await calculateTeamSize(userId)
+    const totalVolume = await calculateTeamVolume(userId)
+    const levels = await calculateNetworkLevels(userId)
+
+    return NextResponse.json({
+      user: genealogyTree,
+      teamSize,
+      totalVolume,
+      levels
+    })
+  } catch (error) {
+    console.error('Error fetching genealogy data:', error)
+    return NextResponse.json(
+      { error: 'Failed to fetch genealogy data' },
+      { status: 500 }
+    )
+  }
+}
+
+async function buildGenealogyTree(userId: string, level: number): Promise<TeamMember> {
+  const user = await prisma.user.findUnique({
+    where: { id: userId },
+    include: {
+      wallet: true,
+      referrals: {
+        select: {
+          id: true,
+          name: true,
+          email: true,
+          joinedAt: true
+        }
+      }
+    }
+  })
+
+  if (!user) {
+    throw new Error('User not found')
+  }
+
+  // Get direct referrals count
+  const directReferrals = await prisma.user.count({
+    where: { referrerId: userId }
+  })
+
+  const teamMember: TeamMember = {
+    id: user.id,
+    name: user.name || 'Unknown',
+    email: user.email,
+    joinedAt: user.joinedAt.toISOString(),
+    totalEarnings: user.wallet?.totalEarnings || 0,
+    directReferrals,
+    level,
+    children: []
+  }
+
+  // Recursively build children (limit to 5 levels to prevent infinite recursion)
+  if (level < 5 && user.referrals.length > 0) {
+    for (const referral of user.referrals) {
+      const childTree = await buildGenealogyTree(referral.id, level + 1)
+      teamMember.children!.push(childTree)
+    }
+  }
+
+  return teamMember
+}
+
+async function calculateTeamSize(userId: string): Promise<number> {
+  const getAllTeamMembers = async (id: string): Promise<string[]> => {
+    const directReferrals = await prisma.user.findMany({
+      where: { referrerId: id },
+      select: { id: true }
+    })
+
+    let allMembers = directReferrals.map(r => r.id)
+
+    for (const referral of directReferrals) {
+      const subTeam = await getAllTeamMembers(referral.id)
+      allMembers = [...allMembers, ...subTeam]
+    }
+
+    return allMembers
+  }
+
+  const teamMembers = await getAllTeamMembers(userId)
+  return teamMembers.length
+}
+
+async function calculateTeamVolume(userId: string): Promise<number> {
+  const getAllTeamMembers = async (id: string): Promise<string[]> => {
+    const directReferrals = await prisma.user.findMany({
+      where: { referrerId: id },
+      select: { id: true }
+    })
+
+    let allMembers = directReferrals.map(r => r.id)
+
+    for (const referral of directReferrals) {
+      const subTeam = await getAllTeamMembers(referral.id)
+      allMembers = [...allMembers, ...subTeam]
+    }
+
+    return allMembers
+  }
+
+  const teamMembers = await getAllTeamMembers(userId)
+  
+  if (teamMembers.length === 0) return 0
+
+  const volume = await prisma.order.aggregate({
+    where: {
+      userId: { in: teamMembers },
+      status: { in: ['PAID', 'SHIPPED', 'DELIVERED'] }
+    },
+    _sum: { total: true }
+  })
+
+  return volume._sum.total || 0
+}
+
+async function calculateNetworkLevels(userId: string): Promise<number> {
+  const getMaxLevel = async (id: string, currentLevel: number): Promise<number> => {
+    const directReferrals = await prisma.user.findMany({
+      where: { referrerId: id },
+      select: { id: true }
+    })
+
+    if (directReferrals.length === 0) {
+      return currentLevel
+    }
+
+    let maxLevel = currentLevel + 1
+
+    for (const referral of directReferrals) {
+      const level = await getMaxLevel(referral.id, currentLevel + 1)
+      maxLevel = Math.max(maxLevel, level)
+    }
+
+    return maxLevel
+  }
+
+  return await getMaxLevel(userId, 0)
+}