Token Payment

<?php
require __DIR__ . '/../vendor/autoload.php';

use Com\Kodypay\Grpc\Ecom\V1\KodyEcomPaymentsServiceClient;
use Com\Kodypay\Grpc\Ecom\V1\CreateTokenRequest;
use Grpc\ChannelCredentials;

// Configuration
$HOSTNAME = "grpc-staging.kodypay.com";
$API_KEY = "your-api-key";

// Step 1: Initialize SDK client with SSL credentials
$client = new KodyEcomPaymentsServiceClient($HOSTNAME, [
    'credentials' => ChannelCredentials::createSsl()
]);

// Step 2: Set authentication headers with your API key
$metadata = ['X-API-Key' => [$API_KEY]];

// Step 3: Create CreateTokenRequest and set required fields
$request = new CreateTokenRequest();
$request->setStoreId('your-store-id');
$request->setPayerReference('customer_123'); // Customer ID
$request->setReturnUrl('https://your-domain.com/token-callback');
$request->setRecurringProcessingModel('SUBSCRIPTION');

// Step 4: Set optional fields
$request->setTokenReference('token-ref-' . uniqid());
$request->setIdempotencyUuid(uniqid('', true)); // or use: bin2hex(random_bytes(16))
$request->setPayerEmailAddress('customer@example.com');
$request->setPayerPhoneNumber('+1234567890');
$request->setPayerStatement('Card Setup');
$request->setMetadata('{"customer_name": "John Doe"}');

// Step 5: Call CreateCardToken() method and wait for response
list($response, $status) = $client->CreateCardToken($request, $metadata)->wait();

// Step 6: Handle gRPC response status
if ($status->code !== \Grpc\STATUS_OK) {
    echo "Error: " . $status->details . PHP_EOL;
    exit;
}

// Step 7: Process response
if ($response->hasResponse()) {
    $responseData = $response->getResponse();
    echo "Token ID: " . $responseData->getTokenId() . PHP_EOL;
    echo "Token URL: " . $responseData->getCreateTokenUrl() . PHP_EOL;

    // Redirect customer to complete tokenization
    header('Location: ' . $responseData->getCreateTokenUrl());
} else if ($response->hasError()) {
    $error = $response->getError();
    echo "API Error: " . $error->getMessage() . PHP_EOL;
}
?>

import com.kodypay.grpc.ecom.v1.KodyEcomPaymentsServiceGrpc;
import com.kodypay.grpc.ecom.v1.CreateTokenRequest;
import com.kodypay.grpc.ecom.v1.CreateTokenResponse;
import io.grpc.ManagedChannelBuilder;
import io.grpc.Metadata;
import io.grpc.stub.MetadataUtils;
import java.util.UUID;

public class CreateCardTokenExample {
    public static final String HOSTNAME = "grpc-staging.kodypay.com";
    public static final String API_KEY = "your-api-key";

    public static void main(String[] args) {
        // Step 1: Create metadata with API key
        Metadata metadata = new Metadata();
        metadata.put(Metadata.Key.of("X-API-Key", Metadata.ASCII_STRING_MARSHALLER), API_KEY);

        // Step 2: Build secure channel and create client
        var channel = ManagedChannelBuilder.forAddress(HOSTNAME, 443)
            .useTransportSecurity()
            .build();
        var client = KodyEcomPaymentsServiceGrpc.newBlockingStub(channel)
            .withInterceptors(MetadataUtils.newAttachHeadersInterceptor(metadata));

        // Step 3: Create CreateTokenRequest and set required fields
        CreateTokenRequest request = CreateTokenRequest.newBuilder()
            .setStoreId("your-store-id")
            .setPayerReference("customer_123") // Customer ID
            .setReturnUrl("https://your-domain.com/token-callback")
            .setRecurringProcessingModel("SUBSCRIPTION")
            .setTokenReference("token-ref-" + System.currentTimeMillis())
            .setIdempotencyUuid(UUID.randomUUID().toString())
            .setPayerEmailAddress("customer@example.com")
            .setPayerPhoneNumber("+1234567890")
            .setPayerStatement("Card Setup")
            .setMetadata("{\"customer_name\": \"John Doe\"}")
            .build();

        // Step 4: Call CreateCardToken() method and get response
        CreateTokenResponse response = client.createCardToken(request);

        // Step 5: Process response
        if (response.hasResponse()) {
            var responseData = response.getResponse();
            System.out.println("Token ID: " + responseData.getTokenId());
            System.out.println("Token URL: " + responseData.getCreateTokenUrl());

            // Redirect customer to complete tokenization
            // response.sendRedirect(responseData.getCreateTokenUrl());
        } else if (response.hasError()) {
            var error = response.getError();
            System.out.println("API Error: " + error.getMessage());
        }
    }
}

import grpc
import uuid
import kody_clientsdk_python.ecom.v1.ecom_pb2 as kody_model
import kody_clientsdk_python.ecom.v1.ecom_pb2_grpc as kody_client

def create_card_token():
    # Configuration
    HOSTNAME = "grpc-staging.kodypay.com:443"
    API_KEY = "your-api-key"

    # Step 1: Create secure channel
    channel = grpc.secure_channel(HOSTNAME, grpc.ssl_channel_credentials())

    # Step 2: Create client and set metadata with API key
    client = kody_client.KodyEcomPaymentsServiceStub(channel)
    metadata = [("x-api-key", API_KEY)]

    # Step 3: Create CreateTokenRequest and set required fields
    request = kody_model.CreateTokenRequest(
        store_id="your-store-id",
        payer_reference="customer_123",  # Customer ID
        return_url="https://your-domain.com/token-callback",
        recurring_processing_model="SUBSCRIPTION",
        token_reference=f"token-ref-{int(time.time())}",
        idempotency_uuid=str(uuid.uuid4()),
        payer_email_address="customer@example.com",
        payer_phone_number="+1234567890",
        payer_statement="Card Setup",
        metadata='{"customer_name": "John Doe"}'
    )

    # Step 4: Call CreateCardToken() method and get response
    response = client.CreateCardToken(request, metadata=metadata)

    # Step 5: Process response
    if response.HasField("response"):
        response_data = response.response
        print(f"Token ID: {response_data.token_id}")
        print(f"Token URL: {response_data.create_token_url}")

        # Redirect customer to complete tokenization
        # webbrowser.open(response_data.create_token_url)
    elif response.HasField("error"):
        error = response.error
        print(f"API Error: {error.message}")

if __name__ == "__main__":
    create_card_token()

using Grpc.Core;
using Grpc.Net.Client;
using Com.Kodypay.Ecom.V1;
using System;

class Program
{
    static async Task Main(string[] args)
    {
        // Configuration
        var HOSTNAME = "grpc-staging.kodypay.com";
        var API_KEY = "your-api-key";

        // Step 1: Create secure channel
        var channel = GrpcChannel.ForAddress("https://" + HOSTNAME);

        // Step 2: Create client
        var client = new KodyEcomPaymentsService.KodyEcomPaymentsServiceClient(channel);

        // Step 3: Set authentication headers with API key
        var metadata = new Metadata
        {
            { "X-API-Key", API_KEY }
        };

        // Step 4: Create CreateTokenRequest and set required fields
        var request = new CreateTokenRequest
        {
            StoreId = "your-store-id",
            PayerReference = "customer_123", // Customer ID
            ReturnUrl = "https://your-domain.com/token-callback",
            RecurringProcessingModel = "SUBSCRIPTION",
            TokenReference = $"token-ref-{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}",
            IdempotencyUuid = Guid.NewGuid().ToString(),
            PayerEmailAddress = "customer@example.com",
            PayerPhoneNumber = "+1234567890",
            PayerStatement = "Card Setup",
            Metadata = "{\"customer_name\": \"John Doe\"}"
        };

        try
        {
            // Step 5: Call CreateCardToken() method and get response
            var response = await client.CreateCardTokenAsync(request, metadata);

            // Step 6: Process response
            if (response.ResponseCase == CreateTokenResponse.ResponseOneofCase.Response)
            {
                var responseData = response.Response;
                Console.WriteLine($"Token ID: {responseData.TokenId}");
                Console.WriteLine($"Token URL: {responseData.CreateTokenUrl}");

                // Redirect customer to complete tokenization
                // Response.Redirect(responseData.CreateTokenUrl);
            }
            else if (response.ResponseCase == CreateTokenResponse.ResponseOneofCase.Error)
            {
                var error = response.Error;
                Console.WriteLine($"API Error: {error.Message}");
            }
        }
        catch (RpcException ex)
        {
            Console.WriteLine($"gRPC Error: {ex.Status.StatusCode} - {ex.Status.Detail}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Exception: {ex.Message}");
        }
    }
}