Client Integration

use serde::{Deserialize, Serialize};
use reqwest::header::{HeaderMap, HeaderValue};

#[derive(Serialize)]
struct Price {
    total: f64,
    currency: String,
}

#[derive(Serialize)]
struct Customer {
    email: String,
}

#[derive(Serialize)]
struct CheckoutSession {
    reference_id: String,
    price: Price,
    locale: String,
    error_callback_url: String,
    success_callback_url: String,
    customer: Customer,
}

#[derive(Deserialize)]
struct CheckoutResponse {
    redirect_url: String,
}

async fn create_checkout_session(amount: f64, currency: &str) -> Result<String, Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let mut headers = HeaderMap::new();
    headers.insert("x-ivx-api-key", HeaderValue::from_static("YOUR_API_KEY"));
    
    let session = CheckoutSession {
        reference_id: "order_123".to_string(),
        price: Price {
            total: amount,
            currency: currency.to_string(),
        },
        locale: "en".to_string(),
        error_callback_url: "https://example.com/error".to_string(),
        success_callback_url: "https://example.com/success".to_string(),
        customer: Customer {
            email: "[email protected]".to_string(),
        },
    };

    let response = client
        .post("https://api.sand.getivy.de/api/service/checkout/session/create")
        .headers(headers)
        .json(&session)
        .send()
        .await?
        .json::<CheckoutResponse>()
        .await?;

    Ok(response.redirect_url)
}

<?php

function createCheckoutSession($amount, $currency = 'EUR', $locale = 'en') {
    $apiKey = 'YOUR_API_KEY';
    $url = 'https://api.sand.getivy.de/api/service/checkout/session/create';

    $data = [
        'reference_id' => 'order_123', // Your internal unique order reference
        'price' => [
            'total' => $amount,
            'currency' => $currency
        ],
        'locale' => $locale,
        'error_callback_url' => 'https://example.com/error',
        'success_callback_url' => 'https://example.com/success',
        'customer' => [
            'email' => '[email protected]'
        ]
    ];

    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => json_encode($data),
        CURLOPT_HTTPHEADER => [
            'Content-Type: application/json',
            'x-ivx-api-key: ' . $apiKey
        ]
    ]);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode !== 200) {
        throw new Exception('Failed to create checkout session');
    }

    $result = json_decode($response, true);
    return $result['redirect_url'];
}

// Example usage in an endpoint
try {
    $amount = $_POST['amount'] ?? 0;
    $currency = $_POST['currency'] ?? 'EUR';
    
    $redirectUrl = createCheckoutSession($amount, $currency);
    header('Content-Type: application/json');
    echo json_encode(['url' => $redirectUrl]);
} catch (Exception $e) {
    http_response_code(400);
    header('Content-Type: application/json');
    echo json_encode(['error' => $e->getMessage()]);
}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import requests

app = FastAPI()

class CheckoutRequest(BaseModel):
    amount: float
    currency: str = "EUR"
    locale: str = "en"

@app.post("/api/checkout")
async def create_checkout_session(request: CheckoutRequest):
    api_key = "YOUR_API_KEY"
    url = "https://api.sand.getivy.de/api/service/checkout/session/create"
    
    payload = {
        "reference_id": "order_123",  # Your internal unique order reference
        "price": {
            "total": request.amount,
            "currency": request.currency
        },
        "locale": request.locale,
        "error_callback_url": "https://example.com/error",
        "success_callback_url": "https://example.com/success",
        "customer": {
            "email": "[email protected]"
        }
    }
    
    headers = {
        "Content-Type": "application/json",
        "x-ivx-api-key": api_key
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()
        result = response.json()
        return {"url": result["redirect_url"]}
    except requests.exceptions.RequestException as e:
        raise HTTPException(status_code=400, detail=f"Failed to create checkout session: {str(e)}")

# Run with: uvicorn checkout:app --reload

package com.example.service;

import org.json.JSONObject;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class IvyCheckoutService {
    
    private static final String API_URL = "https://api.sand.getivy.de/api/service/checkout/session/create";
    private static final String API_KEY = "YOUR_API_KEY";
    
    public String createCheckoutSession(double amount, String currency, String locale) {
        RestTemplate restTemplate = new RestTemplate();
        
        // Set headers
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("x-ivx-api-key", API_KEY);
        
        // Create request body
        JSONObject price = new JSONObject();
        price.put("total", amount);
        price.put("currency", currency);
        
        JSONObject customer = new JSONObject();
        customer.put("email", "[email protected]");
        
        JSONObject requestBody = new JSONObject();
        requestBody.put("reference_id", "order_123");
        requestBody.put("price", price);
        requestBody.put("locale", locale);
        requestBody.put("error_callback_url", "https://example.com/error");
        requestBody.put("success_callback_url", "https://example.com/success");
        requestBody.put("customer", customer);
        
        // Create request entity
        HttpEntity<String> request = new HttpEntity<>(requestBody.toString(), headers);
        
        // Make API call
        ResponseEntity<String> response = restTemplate.postForEntity(API_URL, request, String.class);
        
        // Parse response
        JSONObject responseBody = new JSONObject(response.getBody());
        return responseBody.getString("redirect_url");
    }
}

package com.example.controller;

import com.example.service.IvyCheckoutService;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
public class CheckoutController {
    
    @Autowired
    private IvyCheckoutService ivyCheckoutService;
    
    @PostMapping("/api/checkout")
    public ResponseEntity<String> createCheckout(@RequestBody Map<String, Object> request) {
        try {
            double amount = Double.parseDouble(request.getOrDefault("amount", 0).toString());
            String currency = request.getOrDefault("currency", "EUR").toString();
            String locale = request.getOrDefault("locale", "en").toString();
            
            String redirectUrl = ivyCheckoutService.createCheckoutSession(amount, currency, locale);
            
            JSONObject response = new JSONObject();
            response.put("url", redirectUrl);
            
            return ResponseEntity.ok(response.toString());
        } catch (Exception e) {
            JSONObject error = new JSONObject();
            error.put("error", "Failed to create checkout session: " + e.getMessage());
            return ResponseEntity.badRequest().body(error.toString());
        }
    }
}