first commit

app/api/partnership/apply/route.ts

@@ -0,0 +1,222 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/prisma'
+import bcrypt from 'bcryptjs'
+import { EmailService } from '@/lib/email'
+
+const emailService = new EmailService()
+
+interface PartnerApplicationData {
+  // Personal Information
+  firstName: string
+  lastName: string
+  email: string
+  phone: string
+  
+  // Business Information
+  businessName?: string
+  businessType: string
+  experience: string
+  
+  // Partnership Details
+  partnershipTier: 'Diamond' | 'Gold' | 'Silver'
+  expectedCustomers: number
+  
+  // Address Information
+  address: string
+  city: string
+  state: string
+  zipCode: string
+  
+  // Additional Information
+  motivation: string
+  marketingPlan: string
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const data: PartnerApplicationData = await request.json()
+
+    // Validate required fields
+    if (!data.firstName || !data.lastName || !data.email || !data.phone || !data.partnershipTier) {
+      return NextResponse.json(
+        { success: false, message: 'Missing required fields' },
+        { status: 400 }
+      )
+    }
+
+    // Check if user already exists
+    const existingUser = await prisma.user.findUnique({
+      where: { email: data.email }
+    })
+
+    if (existingUser) {
+      return NextResponse.json(
+        { success: false, message: 'User with this email already exists' },
+        { status: 400 }
+      )
+    }
+
+    // Check tier availability
+    const tierAvailability = await checkTierAvailability(data.partnershipTier)
+    if (!tierAvailability.available) {
+      return NextResponse.json(
+        { 
+          success: false, 
+          message: `${data.partnershipTier} tier is currently full. Please select another tier.`,
+          availableTiers: tierAvailability.availableTiers
+        },
+        { status: 400 }
+      )
+    }
+
+    // Generate random password and referral code
+    const randomPassword = Math.random().toString(36).slice(-8) + Math.random().toString(36).slice(-8)
+    const hashedPassword = await bcrypt.hash(randomPassword, 12)
+    const referralCode = generateReferralCode(data.firstName, data.lastName)
+
+    // Create user with MEMBER role
+    const newUser = await prisma.user.create({
+      data: {
+        name: `${data.firstName} ${data.lastName}`,
+        email: data.email,
+        phone: data.phone,
+        password: hashedPassword,
+        role: 'MEMBER',
+        address: `${data.address}, ${data.city}, ${data.state} ${data.zipCode}`,
+        isActive: true,
+        partnerTier: data.partnershipTier,
+        minReferrals: 3, // Partners need to add minimum 3 members
+        referralCode: referralCode,
+      }
+    })
+
+    // Create address record
+    await prisma.address.create({
+      data: {
+        userId: newUser.id,
+        firstName: data.firstName,
+        lastName: data.lastName,
+        company: data.businessName || '',
+        address1: data.address,
+        city: data.city,
+        state: data.state,
+        zipCode: data.zipCode,
+        phone: data.phone,
+        isDefault: true,
+        type: 'HOME'
+      }
+    })
+
+    // Store form response for admin review
+    await prisma.formResponse.create({
+      data: {
+        formId: 'partnership_application',
+        userId: newUser.id,
+        data: {
+          ...data,
+          applicationStatus: 'approved', // Auto-approve for now
+          partnerTier: data.partnershipTier
+        },
+        status: 'approved'
+      }
+    })
+
+    // Create wallet for the partner
+    await prisma.wallet.create({
+      data: {
+        userId: newUser.id,
+        balance: 0,
+        totalEarnings: 0,
+        totalWithdrawn: 0
+      }
+    })
+
+    try {
+      // Send admin notification email
+      await emailService.sendPartnerApplicationAdminNotification(data, newUser)
+
+      // Send confirmation email to partner
+      await emailService.sendPartnerWelcomeEmail(data, newUser, randomPassword)
+    } catch (emailError) {
+      console.error('Email sending failed:', emailError)
+      // Don't fail the request if email fails
+    }
+
+    return NextResponse.json({
+      success: true,
+      message: 'Partnership application submitted successfully! Check your email for login details.',
+      user: {
+        id: newUser.id,
+        email: newUser.email,
+        name: newUser.name,
+        role: newUser.role,
+        referralCode: newUser.referralCode
+      }
+    })
+
+  } catch (error) {
+    console.error('Partnership application error:', error)
+    return NextResponse.json(
+      { success: false, message: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}
+
+// Generate referral code
+function generateReferralCode(firstName: string, lastName: string): string {
+  const initials = (firstName.charAt(0) + lastName.charAt(0)).toUpperCase()
+  const timestamp = Date.now().toString().slice(-6)
+  return `${initials}${timestamp}`
+}
+
+// Check tier availability
+async function checkTierAvailability(requestedTier: string) {
+  // Define tier limits
+  const tierLimits = {
+    Diamond: 100,  // Maximum 100 Diamond partners
+    Gold: 500,     // Maximum 500 Gold partners
+    Silver: 1000   // Maximum 1000 Silver partners
+  }
+
+  // Count current partners for each tier
+  const tierCounts = await prisma.user.groupBy({
+    by: ['partnerTier'],
+    where: {
+      role: 'MEMBER',
+      partnerTier: {
+        in: ['Diamond', 'Gold', 'Silver']
+      }
+    },
+    _count: {
+      _all: true
+    }
+  })
+
+  // Create a map of current counts
+  const currentCounts: Record<string, number> = {}
+  tierCounts.forEach(tier => {
+    if (tier.partnerTier) {
+      currentCounts[tier.partnerTier] = tier._count._all
+    }
+  })
+
+  // Check availability for all tiers
+  const availability = {
+    Diamond: (currentCounts.Diamond || 0) < tierLimits.Diamond,
+    Gold: (currentCounts.Gold || 0) < tierLimits.Gold,
+    Silver: (currentCounts.Silver || 0) < tierLimits.Silver
+  }
+
+  // Get available tiers
+  const availableTiers = Object.entries(availability)
+    .filter(([_, available]) => available)
+    .map(([tier, _]) => tier)
+
+  return {
+    available: availability[requestedTier as keyof typeof availability] || false,
+    availableTiers,
+    currentCounts,
+    limits: tierLimits
+  }
+}