SDK upgrade guide

package main

import (
	"errors"
	"fmt"
	"os"
	"strings"

	tinker "github.com/Tinker-Digital-Ltd/tinker-payments-go-sdk/tinker"
	apierrors "github.com/Tinker-Digital-Ltd/tinker-payments-go-sdk/tinker/errors"
	"github.com/Tinker-Digital-Ltd/tinker-payments-go-sdk/tinker/model/dto"
	"github.com/Tinker-Digital-Ltd/tinker-payments-go-sdk/tinker/types"
)

func check(err error) {
	if err != nil {
		panic(err)
	}
}

func main() {
	client := tinker.NewPayments(os.Getenv("TINKER_PUBLIC_KEY"), os.Getenv("TINKER_SECRET_KEY"), nil, os.Getenv("TINKER_BASE_URL"))
	tx := client.Transactions()

	providers, err := tx.Capabilities("KES", "KE")
	check(err)
	for _, p := range providers {
		if p.Gateway == "futurepay" {
			fmt.Println("capabilities", p.Gateway, "refund="+p.Capabilities["refund"])
		}
	}

	started, err := tx.Initiate(&dto.InitiatePaymentRequestDto{Amount: 100, Currency: "KES", Gateway: "futurepay", MerchantReference: "ORDER-2", ReturnURL: "https://example.com/return"})
	check(err)
	fmt.Println("initiated", started.InitiationData.PaymentReference, started.Status)

	for _, reference := range []string{"PAY-future1", "PAY-done", "PAY-new"} {
		found, err := tx.Query(&dto.QueryPaymentRequestDto{PaymentReference: reference, Gateway: "futurepay"})
		check(err)
		switch found.Status {
		case types.SUCCESS, types.REVERSED, types.FAILED, types.CANCELLED:
			fmt.Println(reference, found.Status)
		default:
			fmt.Println(reference, found.Status, "keep waiting")
		}
	}

	phone, method := "+254712345678", "apple_pay"
	_, err = tx.Initiate(&dto.InitiatePaymentRequestDto{Amount: 100, Currency: "KES", Gateway: types.MPESA, MerchantReference: "ORDER-1", ReturnURL: "https://example.com/return", CustomerPhone: &phone, PaymentMethod: &method})
	var refused *apierrors.FeatureNotSupportedException
	if errors.As(err, &refused) {
		fmt.Println("unsupported", refused.Gateway, refused.Feature, strings.Join(refused.Alternatives, ","))
	}
}

const { TinkerPayments, errors } = require('tinker-payments-node-sdk');

const client = new TinkerPayments(process.env.TINKER_PUBLIC_KEY, process.env.TINKER_SECRET_KEY, { baseUrl: process.env.TINKER_BASE_URL });
const tx = client.transactions();

(async () => {
  const { providers } = await tx.capabilities('KES', 'KE');
  for (const p of providers.filter((p) => p.gateway === 'futurepay')) {
    console.log('capabilities', p.gateway, 'refund=' + p.capabilities.refund);
  }

  const started = await tx.initiate({ amount: 100, currency: 'KES', gateway: 'futurepay', merchantReference: 'ORDER-2', returnUrl: 'https://example.com/return' });
  console.log('initiated', started.initiationData.paymentReference, started.status);

  for (const reference of ['PAY-future1', 'PAY-done', 'PAY-new']) {
    const found = await tx.query({ reference, gateway: 'futurepay' });
    const settled = ['success', 'reversed', 'failed', 'cancelled'].includes(found.status);
    console.log(reference, found.status + (settled ? '' : ' keep waiting'));
  }

  try {
    await tx.initiate({ amount: 100, currency: 'KES', gateway: 'mpesa', merchantReference: 'ORDER-1', returnUrl: 'https://example.com/return', customerPhone: '+254712345678', paymentMethod: 'apple_pay' });
  } catch (error) {
    if (!(error instanceof errors.FeatureNotSupportedError)) throw error;
    console.log('unsupported', error.gateway, error.feature, error.alternatives.join(','));
  }
})();

import os

from tinker import FeatureNotSupportedError, TinkerClient

client = TinkerClient(os.environ["TINKER_PUBLIC_KEY"], os.environ["TINKER_SECRET_KEY"], base_url=os.environ.get("TINKER_BASE_URL"))
tx = client.transactions()

for p in tx.capabilities("KES", "KE")["providers"]:
    if p["gateway"] == "futurepay":
        print("capabilities", p["gateway"], "refund=" + p["capabilities"]["refund"])

started = tx.initiate({"amount": 100, "currency": "KES", "gateway": "futurepay", "merchantReference": "ORDER-2", "returnUrl": "https://example.com/return"})
print("initiated", started.initiation_data["paymentReference"], started.status)

for reference in ["PAY-future1", "PAY-done", "PAY-new"]:
    found = tx.query({"reference": reference, "gateway": "futurepay"})
    settled = found.status in ("success", "reversed", "failed", "cancelled")
    print(reference, found.status + ("" if settled else " keep waiting"))

try:
    tx.initiate({"amount": 100, "currency": "KES", "gateway": "mpesa", "merchantReference": "ORDER-1", "returnUrl": "https://example.com/return", "customerPhone": "+254712345678", "paymentMethod": "apple_pay"})
except FeatureNotSupportedError as error:
    print("unsupported", error.gateway, error.feature, ",".join(error.alternatives))

<?php
declare(strict_types=1);

use Tinker\Enum\PaymentStatus;
use Tinker\Exception\FeatureNotSupportedException;
use Tinker\Model\DTO\InitiatePaymentRequest;
use Tinker\Model\DTO\QueryPaymentRequest;
use Tinker\TinkerPayments;

$client = new TinkerPayments(getenv('TINKER_PUBLIC_KEY'), getenv('TINKER_SECRET_KEY'), baseUrl: getenv('TINKER_BASE_URL') ?: null);
$tx = $client->transactions();

foreach ($tx->capabilities('KES', 'KE')['providers'] as $p) {
    if ('futurepay' === $p['gateway']) {
        echo 'capabilities ', $p['gateway'], ' refund=', $p['capabilities']['refund'], "\n";
    }
}

$started = $tx->initiate(new InitiatePaymentRequest(100.0, 'KES', 'futurepay', 'ORDER-2', 'https://example.com/return'));
echo 'initiated ', $started->getInitiationData()->paymentReference, ' ', PaymentStatus::text($started->status), "\n";

foreach (['PAY-future1', 'PAY-done', 'PAY-new'] as $reference) {
    $status = PaymentStatus::text($tx->query(new QueryPaymentRequest($reference, 'futurepay'))->status);
    $settled = in_array($status, ['success', 'reversed', 'failed', 'cancelled'], true);
    echo $reference, ' ', $status, $settled ? '' : ' keep waiting', "\n";
}

try {
    $tx->initiate(new InitiatePaymentRequest(100.0, 'KES', 'mpesa', 'ORDER-1', 'https://example.com/return', customerPhone: '+254712345678', paymentMethod: 'apple_pay'));
} catch (FeatureNotSupportedException $error) {
    echo 'unsupported ', $error->getGateway(), ' ', $error->getFeature(), ' ', implode(',', $error->getAlternatives()), "\n";
}

require 'tinker'

client = Tinker::Payments.new(api_public_key: ENV['TINKER_PUBLIC_KEY'], api_secret_key: ENV['TINKER_SECRET_KEY'], base_url: ENV['TINKER_BASE_URL'])
tx = client.transactions

tx.capabilities(currency: 'KES', country: 'KE')['providers'].each do |p|
  puts "capabilities #{p['gateway']} refund=#{p['capabilities']['refund']}" if p['gateway'] == 'futurepay'
end

dto = Tinker::Model::Dto
started = tx.initiate(dto::InitiatePaymentRequestDto.new(amount: 100.0, currency: 'KES', gateway: 'futurepay', merchant_reference: 'ORDER-2', return_url: 'https://example.com/return'))
puts "initiated #{started.initiation_data.payment_reference} #{started.status}"

%w[PAY-future1 PAY-done PAY-new].each do |reference|
  status = tx.query(dto::QueryPaymentRequestDto.new(payment_reference: reference, gateway: 'futurepay')).status
  settled = %w[success reversed failed cancelled].include?(status)
  puts "#{reference} #{status}#{settled ? '' : ' keep waiting'}"
end

begin
  tx.initiate(dto::InitiatePaymentRequestDto.new(amount: 100.0, currency: 'KES', gateway: 'mpesa', merchant_reference: 'ORDER-1', return_url: 'https://example.com/return', customer_phone: '+254712345678', payment_method: 'apple_pay'))
rescue Tinker::Exception::FeatureNotSupportedException => e
  puts "unsupported #{e.gateway} #{e.feature} #{e.alternatives.join(',')}"
end

import co.ke.tinker.Payments;
import co.ke.tinker.enums.PaymentStatus;
import co.ke.tinker.exception.FeatureNotSupportedException;
import co.ke.tinker.model.Transaction;
import co.ke.tinker.model.dto.InitiatePaymentRequestDto;
import co.ke.tinker.model.dto.QueryPaymentRequestDto;
import co.ke.tinker.model.lifecycle.ProviderCapability;

public class Example {
    public static void main(String[] args) {
        Payments client = new Payments(System.getenv("TINKER_PUBLIC_KEY"), System.getenv("TINKER_SECRET_KEY"), null, System.getenv("TINKER_BASE_URL"));

        for (ProviderCapability p : client.transactions().capabilities("KES", "KE").getProviders()) {
            if (p.getGateway().equals("futurepay")) {
                System.out.println("capabilities " + p.getGateway() + " refund=" + p.getCapabilities().get("refund"));
            }
        }

        Transaction started = client.transactions().initiate(new InitiatePaymentRequestDto(100.0, "KES", "futurepay", "ORDER-2", "https://example.com/return"));
        System.out.println("initiated " + started.getInitiationData().getPaymentReference() + " " + started.getStatusValue());

        for (String reference : new String[] {"PAY-future1", "PAY-done", "PAY-new"}) {
            Transaction found = client.transactions().query(new QueryPaymentRequestDto(reference, "futurepay"));
            boolean settled = found.getStatus() == PaymentStatus.SUCCESS || found.getStatus() == PaymentStatus.REVERSED
                    || found.getStatus() == PaymentStatus.FAILED || found.getStatus() == PaymentStatus.CANCELLED;
            System.out.println(reference + " " + found.getStatusValue() + (settled ? "" : " keep waiting"));
        }

        try {
            client.transactions().initiate(new InitiatePaymentRequestDto(100.0, "KES", "mpesa", "ORDER-1", "https://example.com/return", "+254712345678", null, null, null, "apple_pay"));
        } catch (FeatureNotSupportedException error) {
            System.out.println("unsupported " + error.getGateway() + " " + error.getFeature() + " " + String.join(",", error.getAlternatives()));
        }
    }
}

import co.ke.tinker.Payments
import co.ke.tinker.enums.PaymentStatus
import co.ke.tinker.exception.FeatureNotSupportedException
import co.ke.tinker.model.dto.InitiatePaymentRequestDto
import co.ke.tinker.model.dto.QueryPaymentRequestDto

fun main() {
    val client = Payments(System.getenv("TINKER_PUBLIC_KEY"), System.getenv("TINKER_SECRET_KEY"), baseUrl = System.getenv("TINKER_BASE_URL"))
    val tx = client.transactions()

    for (p in tx.capabilities("KES", "KE").providers.filter { it.gateway == "futurepay" }) {
        println("capabilities ${p.gateway} refund=${p.capabilities["refund"]}")
    }

    val started = tx.initiate(InitiatePaymentRequestDto(100.0, "KES", "futurepay", "ORDER-2", "https://example.com/return"))
    println("initiated ${started.initiationData?.paymentReference} ${started.rawStatus}")

    for (reference in listOf("PAY-future1", "PAY-done", "PAY-new")) {
        val found = tx.query(QueryPaymentRequestDto(reference, "futurepay"))
        val settled = found.status in listOf(PaymentStatus.SUCCESS, PaymentStatus.REVERSED, PaymentStatus.FAILED, PaymentStatus.CANCELLED)
        println("$reference ${found.rawStatus}${if (settled) "" else " keep waiting"}")
    }

    try {
        tx.initiate(InitiatePaymentRequestDto(100.0, "KES", "mpesa", "ORDER-1", "https://example.com/return", customerPhone = "+254712345678", paymentMethod = "apple_pay"))
    } catch (error: FeatureNotSupportedException) {
        println("unsupported ${error.gateway} ${error.feature} ${error.alternatives.joinToString(",")}")
    }
}