Dynamisk Prissättning Kassa med Betala Vad Du Vill

import DodoPayments from 'dodopayments';

// Initialize the Dodo Payments client
const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});

async function createDynamicPricingCheckout(
  productId: string,
  amountInCents: number,
  returnUrl: string
) {
  try {
    const session = await client.checkoutSessions.create({
      product_cart: [
        {
          product_id: productId,
          quantity: 1,
          // Dynamic amount in cents (e.g., 1500 = $15.00)
          amount: amountInCents
        }
      ],
      return_url: returnUrl,
      // Optional: Pre-fill customer information
      customer: {
        email: 'customer@example.com',
        name: 'John Doe'
      },
      // Optional: Add metadata for tracking
      metadata: {
        order_id: 'order_123',
        pricing_tier: 'custom'
      }
    });

    console.log('Checkout URL:', session.checkout_url);
    console.log('Session ID:', session.session_id);
    
    return session;
  } catch (error) {
    console.error('Failed to create checkout session:', error);
    throw error;
  }
}

// Example: Create checkout with $25.00 (2500 cents)
const session = await createDynamicPricingCheckout(
  'prod_123abc456def',
  2500, // $25.00 in cents
  'https://yoursite.com/checkout/success'
);

// Example: Create checkout with $10.00 (1000 cents)
const session2 = await createDynamicPricingCheckout(
  'prod_123abc456def',
  1000, // $10.00 in cents
  'https://yoursite.com/checkout/success'
);

import os
from dodopayments import DodoPayments

# Initialize the Dodo Payments client
client = DodoPayments(
    bearer_token=os.environ.get("DODO_PAYMENTS_API_KEY"),
)

def create_dynamic_pricing_checkout(
    product_id: str,
    amount_in_cents: int,
    return_url: str
):
    """
    Create a checkout session with dynamic pricing.
    
    Args:
        product_id: The product ID with Pay What You Want enabled
        amount_in_cents: The amount in cents (e.g., 2500 for $25.00)
        return_url: URL to redirect after payment completion
    
    Returns:
        Session object with checkout_url and session_id
    """
    try:
        session = client.checkout_sessions.create(
            product_cart=[
                {
                    "product_id": product_id,
                    "quantity": 1,
                    # Dynamic amount in cents (e.g., 1500 = $15.00)
                    "amount": amount_in_cents
                }
            ],
            return_url=return_url,
            # Optional: Pre-fill customer information
            customer={
                "email": "customer@example.com",
                "name": "John Doe"
            },
            # Optional: Add metadata for tracking
            metadata={
                "order_id": "order_123",
                "pricing_tier": "custom"
            }
        )
        
        print(f"Checkout URL: {session.checkout_url}")
        print(f"Session ID: {session.session_id}")
        
        return session
    except Exception as error:
        print(f"Failed to create checkout session: {error}")
        raise error

# Example: Create checkout with $25.00 (2500 cents)
session = create_dynamic_pricing_checkout(
    "prod_123abc456def",
    2500,  # $25.00 in cents
    "https://yoursite.com/checkout/success"
)

# Example: Create checkout with $10.00 (1000 cents)
session2 = create_dynamic_pricing_checkout(
    "prod_123abc456def",
    1000,  # $10.00 in cents
    "https://yoursite.com/checkout/success"
)

async function createCustomerChoiceCheckout(
  productId: string,
  returnUrl: string
) {
  try {
    const session = await client.checkoutSessions.create({
      product_cart: [
        {
          product_id: productId,
          quantity: 1
          // No amount field - customer will choose their price
        }
      ],
      return_url: returnUrl,
      customer: {
        email: 'customer@example.com',
        name: 'John Doe'
      }
    });

    return session;
  } catch (error) {
    console.error('Failed to create checkout session:', error);
    throw error;
  }
}

def create_customer_choice_checkout(
    product_id: str,
    return_url: str
):
    """
    Create a checkout session where customers choose their own price.
    """
    try:
        session = client.checkout_sessions.create(
            product_cart=[
                {
                    "product_id": product_id,
                    "quantity": 1
                    # No amount field - customer will choose their price
                }
            ],
            return_url=return_url,
            customer={
                "email": "customer@example.com",
                "name": "John Doe"
            }
        )
        
        return session
    except Exception as error:
        print(f"Failed to create checkout session: {error}")
        raise error

async function createValidatedCheckout(
  productId: string,
  amountInCents: number,
  minAmount: number,
  maxAmount: number | null
) {
  // Validate minimum
  if (amountInCents < minAmount) {
    throw new Error(
      `Amount ${amountInCents} is below minimum ${minAmount}`
    );
  }
  
  // Validate maximum (if set)
  if (maxAmount !== null && amountInCents > maxAmount) {
    throw new Error(
      `Amount ${amountInCents} exceeds maximum ${maxAmount}`
    );
  }
  
  // Create checkout session
  return await client.checkoutSessions.create({
    product_cart: [
      {
        product_id: productId,
        quantity: 1,
        amount: amountInCents
      }
    ],
    return_url: 'https://yoursite.com/success'
  });
}

def create_validated_checkout(
    product_id: str,
    amount_in_cents: int,
    min_amount: int,
    max_amount: int | None
):
    """
    Create a checkout session with amount validation.
    """
    # Validate minimum
    if amount_in_cents < min_amount:
        raise ValueError(
            f"Amount {amount_in_cents} is below minimum {min_amount}"
        )
    
    # Validate maximum (if set)
    if max_amount is not None and amount_in_cents > max_amount:
        raise ValueError(
            f"Amount {amount_in_cents} exceeds maximum {max_amount}"
        )
    
    # Create checkout session
    return client.checkout_sessions.create(
        product_cart=[
            {
                "product_id": product_id,
                "quantity": 1,
                "amount": amount_in_cents
            }
        ],
        return_url="https://yoursite.com/success"
    )