monacousa-portal/server/api/events/[id]/rsvp.post.ts

// server/api/events/[id]/rsvp.post.ts
import { createNocoDBEventsClient } from '~/server/utils/nocodb-events';
import { getMemberByKeycloakId } from '~/server/utils/nocodb';
import { createSessionManager } from '~/server/utils/session';
import type { EventRSVPRequest } from '~/utils/types';

export default defineEventHandler(async (event) => {
  try {
    const eventId = getRouterParam(event, 'id');
    const body = await readBody(event) as EventRSVPRequest;
    
    if (!eventId) {
      throw createError({
        statusCode: 400,
        statusMessage: 'Event ID is required'
      });
    }

    // Get user session using the proper SessionManager
    const sessionManager = createSessionManager();
    const cookieHeader = getHeader(event, 'cookie');
    const session = sessionManager.getSession(cookieHeader);
    
    if (!session || !session.user) {
      throw createError({
        statusCode: 401,
        statusMessage: 'Authentication required'
      });
    }

    const eventsClient = createNocoDBEventsClient();

    // Get the event details
    const eventDetails = await eventsClient.findOne(eventId);
    if (!eventDetails) {
      throw createError({
        statusCode: 404,
        statusMessage: 'Event not found'
      });
    }

    // Check if event is active
    if (eventDetails.status !== 'active') {
      throw createError({
        statusCode: 400,
        statusMessage: 'Cannot RSVP to inactive events'
      });
    }

    // Check if event is in the past
    const eventDate = new Date(eventDetails.start_datetime);
    const now = new Date();
    if (eventDate < now) {
      throw createError({
        statusCode: 400,
        statusMessage: 'Cannot RSVP to past events'
      });
    }

    // Get member details for pricing logic
    const member = await getMemberByKeycloakId(session.user.id);
    if (!member) {
      throw createError({
        statusCode: 404,
        statusMessage: 'Member record not found'
      });
    }

    // Generate payment reference
    const paymentReference = generatePaymentReference(member.member_id || member.Id);

    // Determine pricing and payment status
    let paymentStatus: 'pending' | 'not_required' | 'paid' | 'overdue' = 'not_required';
    let isMemberPricing = 'false';
    
    if (eventDetails.is_paid === 'true' && body.rsvp_status === 'confirmed') {
      paymentStatus = 'pending';
      
      // Check if member qualifies for member pricing
      const isDuesCurrent = member.current_year_dues_paid === 'true';
      const memberPricingEnabled = eventDetails.member_pricing_enabled === 'true';
      
      if (isDuesCurrent && memberPricingEnabled) {
        isMemberPricing = 'true';
      }
    }

    // Create RSVP record
    const rsvpData = {
      record_type: 'rsvp',
      event_id: eventId,
      member_id: member.member_id || member.Id,
      rsvp_status: body.rsvp_status,
      payment_status: paymentStatus,
      payment_reference: paymentReference,
      attended: 'false',
      rsvp_notes: body.rsvp_notes || '',
      is_member_pricing: isMemberPricing,
      created_at: new Date().toISOString(),
      updated_at: new Date().toISOString()
    };

    const newRSVP = await eventsClient.createRSVP(rsvpData);

    // Include payment information in response for paid events
    let responseData: any = newRSVP;
    
    if (eventDetails.is_paid === 'true' && paymentStatus === 'pending') {
      const registrationConfig = await getRegistrationConfig();
      
      responseData = {
        ...newRSVP,
        payment_info: {
          cost: isMemberPricing === 'true' ? 
            eventDetails.cost_members : 
            eventDetails.cost_non_members,
          iban: registrationConfig.iban,
          recipient: registrationConfig.accountHolder,
          reference: paymentReference,
          member_pricing: isMemberPricing === 'true'
        }
      };
    }

    return {
      success: true,
      data: responseData,
      message: (body.rsvp_status as string) === 'waitlist' ? 
        'Added to waitlist - event is full' : 
        'RSVP submitted successfully'
    };

  } catch (error: any) {
    console.error('Error processing RSVP:', error);
    
    if (error.statusCode) {
      throw error;
    }
    
    throw createError({
      statusCode: 500,
      statusMessage: 'Failed to process RSVP'
    });
  }
});

// Helper functions

function generatePaymentReference(memberId: string): string {
  const date = new Date().toISOString().split('T')[0];
  return `EVT-${memberId}-${date}`;
}

async function getRegistrationConfig() {
  // This should fetch from your admin config system
  return {
    iban: 'FR76 1234 5678 9012 3456 7890 123',
    accountHolder: 'MonacoUSA Association'
  };
}