Payments

// From: server/src/modules/reservations/reservations.controller.ts
@Post('/payment')
@ApiOperation({
  summary: 'Crear preferencia de pago',
  description: 'Genera una preferencia de pago (ej: MercadoPago) a partir de la información de la reserva.',
})
async createPreference(@Body() infoReservation) {
  return this.reservationsService.createPreference({ infoReservation });
}

// From: server/src/modules/reservations/reservations.service.ts
async createPreference({ infoReservation }: { infoReservation: CreateReservationDto }) {
  const preference = await new Preference(
    this.mercadoPago.getMercadoPago() as any
  ).create({
    body: {
      items: [{
        id: infoReservation.reservation.id,
        title: "Pago de seña de reserva",
        quantity: 1,
        unit_price: infoReservation.deposit_amount
      }],
      metadata: {
        info_reservation: infoReservation
      },
      notification_url: `${this.serverUrl}/reservations/create-with-payment`
    }
  })
  return { data: preference.init_point }
}

// From: server/src/modules/reservations/reservations.controller.ts
@Post('/create-with-payment')
@ApiOperation({
  summary: 'Crear reserva con pago',
  description: 'Crea una reserva asociada a un pago. Extrae el ID de pago del cuerpo de la solicitud.',
})
async createReservationWithPayment(@Body() infoPayment) {
  const paymentId = extractPaymentId(infoPayment);
  if (!paymentId) return { status: 200 };
  const data = await this.reservationsService.createReservationWithPayment(infoPayment);
  return { data, status: 200 }
}

// From: server/src/modules/reservations/reservations.service.ts
async createReservationWithPayment(infoPayment) {
  const localSupabaseClient = await this.supabaseService.getClient();

  // Fetch payment details from Mercado Pago
  const payment = await new Payment(
    this.mercadoPago.getMercadoPago()
  ).get({ id: infoPayment.data.id });

  const { info_reservation } = payment.metadata;
  const { deposit_amount, reservation } = info_reservation;

  if (payment.status === "approved") {
    const newReservation = formattedReservation(reservation);

    // Create reservation in database
    const responseReservation = await localSupabaseClient
      .from('reservations')
      .insert(newReservation)
      .select()
      .single();

    let responsePayment;
    if (!responseReservation.error) {
      // Create payment record
      const newPayment = {
        reservation_id: responseReservation.data.id,
        amount: deposit_amount,
        status: "PAID",
        payment_provider: "Mercado Pago",
        external_payment_id: payment.id,
      }
      responsePayment = await this.PaymentsService.create(newPayment);
    }

    return {
      reservation: responseReservation,
      payment: responsePayment
    };
  }

  return payment;
}

// From: server/src/modules/payments/dto/create-payment.dto.ts
export class CreatePaymentDto {
  reservation_id: string;           // Links to the reservation
  amount: number;                   // Deposit amount paid
  status: PaymentStatus;            // "PAID"
  payment_provider: string;         // "Mercado Pago"
  external_payment_id?: string | null; // Mercado Pago payment ID
}

// From: server/src/modules/payments/payments.service.ts
@Injectable()
export class PaymentsService {
  constructor(private readonly supabaseService: SupabaseService) {}

  async create(infoPayment) {
    const response = await this.supabaseService
      .getClient()
      .from('payments')
      .insert(infoPayment);
  }
}

// From: server/src/modules/reservations/reservations.controller.ts
@Post('/create-without-payment')
@ApiOperation({
  summary: 'Crear reserva sin pago',
  description: 'Crea una reserva sin requerir pago previo. Solo funciona si la configuración del profesional no requiere depósito.',
})
async createReservationWithoutPayment(@Body() infoPayment) {
  const responseSettings = await this.professionalSettingsxService.get();
  const objectReturn: any = { data: {}, status: 1 }

  if (responseSettings.data) {
    const requiresDeposit = responseSettings.data[0].requires_deposit;
    const { client_id, professional_id } = infoPayment;
    const isManualBlock = client_id === professional_id;

    if (!requiresDeposit || isManualBlock) {
      const data = await this.reservationsService.createReservationWithoutPayment(
        infoPayment
      );
      objectReturn.data = data;
      objectReturn.status = 200;
    }
  }
  return objectReturn;
}

// From: server/src/modules/reservations/reservations.service.ts
async createReservationWithoutPayment(infoPayment) {
  const newReservation = formattedReservation(infoPayment);
  const responseReservation = await this.supabaseService
    .getClient()
    .from('reservations')
    .insert(newReservation)
    .select()
    .single();
  return responseReservation;
}

<div className="status-pay-container">
  <h3 className="flex place-items-center gap-x-2">
    <CircleAlert strokeWidth={2} size={20} />
    <span>Estado del turno: </span>
    <span className="font-bold">Pendiente de pago</span>
  </h3>
  <p>El turno se confirmará una vez acreditado el pago.</p>
</div>

// Display formatted deposit amount
<span className="font-bold">
  ${formattedAmountDeposit({
    deposit_amount: currentProfessionalSettings?.deposit_amount || 12000
  })}
</span>