Java

Dans cette section vous découvrirez comment intégrer Yabetoo avec le SDK Java, par exemple pour une application mobile.

Le SDK Java Yabetoo simplifie l’intégration des paiements en ligne via l’API Yabetoo. Il offre des fonctionnalités puissantes et flexibles pour gérer les paiements, créer des intentions de paiement, les confirmer, et suivre leur état.

Ce guide vous accompagnera étape par étape pour :

1. Installer et configurer le SDK.

2. Créer une intention de paiement.

3. Confirmer une intention de paiement.

4. Récupérer les détails d’un paiement.

Installation du SDK

Prérequis

• Java 8 ou une version plus récente.

• Maven ou Gradle pour la gestion des dépendances.

Installation avec Maven

Ajoutez la dépendance suivante dans votre fichier pom.xml

<dependencies>
    <dependency>
        <groupId>com.yabetoo</groupId>
        <artifactId>yabetoo-sdk</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

Installation avec Gradle

Ajoutez la dépendance suivante dans votre fichier build.gradle

implementation 'com.yabetoo:yabetoo-sdk:1.0.0'

Configuration

Initialisation du SDK

Avant d’utiliser le SDK, vous devez initialiser une instance de la classe Yabetoo. Fournissez simplement votre clé API lors de l’initialisation. Le SDK détecte automatiquement si vous êtes en mode test ou en production.

import com.yabetoo.Yabetoo;

public class PaymentDemo {

    // Initialiser le SDK avec la clé API
    private static final Yabetoo yabetoo = new Yabetoo("sk_test_XXXXXXXXXXXXXXXXXXXXXXXX");

    public static void main(String[] args) {
        System.out.println("SDK initialisé avec succès !");
    }
}

Gestion des paiements avec Yabetoo

Vous pouvez créer des paiements, récupérer des informations sur des paiements spécifiques et gérer les paiements en utilisant la classe Payment.

Yabetoo fonctionne sur un modèle de paiements en deux étapes. Cela signifie que, pour traiter un paiement, vous devez d’abord créer une intention de paiement et ensuite confirmer cette intention pour capturer le montant.

Yabetoo fonctionne sur un modèle de paiements en deux étapes. Cela signifie que, pour traiter un paiement, vous devez d’abord créer une intention de paiement et ensuite confirmer cette intention pour capturer le montant.

Créer une intention de paiement

Une intention de paiement est une ressource qui représente votre souhait de recevoir un paiement pour un montant spécifique. Lorsque vous créez une intention de paiement, vous ne capturez pas immédiatement le montant ; c’est une étape préparatoire.

Nous allons définir une méthode createPaymentIntent pour créer une intention réutilisable :

import com.yabetoo.models.PaymentIntentRequest;
import com.yabetoo.models.PaymentResponse;

import java.util.HashMap;
import java.util.Map;

public class PaymentDemo {

    // Crée une intention de paiement
    public static PaymentResponse createPaymentIntent(int amount, String currency, String description) throws Exception {
        // Préparer les métadonnées (optionnel)
        Map<String, String> metadata = new HashMap<>();
        metadata.put("orderId", "1234");
        metadata.put("note", "Paiement pour commande #1234");

        // Créer la requête
        PaymentIntentRequest request = new PaymentIntentRequest(amount, currency, description, metadata);

        // Envoyer la demande
        return yabetoo.payments.create(request);
    }
}

Utilisation de la méthode

PaymentResponse payment = createPaymentIntent(
  5000,
   "xaf",
   "Paiement pour commande #1234"
);
System.out.println("Intention créée avec ID : " + payment.getId());

Ce code crée une intention de paiement pour un montant de 5000 XAF. La réponse de l’API contient un identifiant unique (id) de l’intention de paiement que vous utiliserez lors de la confirmation.

Confirmer une intention de paiement

Après avoir créé l’intention de paiement, vous devez la confirmer pour capturer le montant. Cela se produit généralement lorsque l’utilisateur final a terminé toutes les étapes nécessaires (comme fournir des informations de paiement ou accepter les conditions générales).

Nous allons maintenant définir une méthode confirmPaymentIntent qui accepte l’intention précédemment créée pour la confirmer.

import com.yabetoo.models.*;
import com.yabetoo.models.ConfirmationResponse;

public class PaymentDemo {

    // Confirme une intention de paiement
    public static ConfirmationResponse confirmPaymentIntent(String paymentId, String clientSecret) throws Exception {
        // Préparer les détails du moyen de paiement (momo)
        Momo momo = new Momo("cg", "242066594471", "mtn");
        PaymentMethodData paymentMethodData = new PaymentMethodData("momo", momo);

        // Créer la requête
        PaymentConfirmationRequest request = new PaymentConfirmationRequest(
                clientSecret, // Client secret de l'intention
                "Jhon",    // Prénom
                "Doe",      // Nom
                "[email protected]", // Email optionnel
                paymentMethodData
        );

        // Confirmer l'intention
        return yabetoo.payments.confirm(paymentId, request);
    }
}

En appelant cette méthode, le montant associé à l’intention de paiement sera capturé, et le paiement sera considéré comme réussi si tout se passe bien.

// Réutiliser l’intention précédemment créée
ConfirmationResponse confirmation = confirmPaymentIntent(
        payment.getId(), payment.getClientSecret()
);
System.out.println("Paiement confirmé avec ID : " + confirmation.getId());

Pour renforcer la sécurité, il est recommandé de toujours vérifier le statut du paiement directement via l’API de Yabetoo. Cela vous permet de vous assurer que le paiement a bien été capturé avant de procéder à la livraison du service ou produit à l’utilisateur.

Le champ status dans la réponse du paiement peut indiquer plusieurs états, comme succeeded, pending, ou failed. Vous devez vérifier que le statut est bien succeeded avant de finaliser le processus de commande.

Avec ce modèle en deux étapes, les développeurs peuvent avoir une meilleure maîtrise du processus de paiement tout en offrant une expérience utilisateur fluide. Vous pouvez adapter ces deux étapes à vos besoins spécifiques (par exemple, pré-autorisation ou paiement différé).

Il est important de gérer les erreurs, car la confirmation d’une intention de paiement peut échouer pour diverses raisons (insuffisance de fonds, informations de paiement incorrectes, etc.).

Récupérer les détails d’un paiement

Pour vérifier les informations d’un paiement, nous définissons une méthode retrievePaymentIntent

import com.yabetoo.models.Intent;

public class PaymentDemo {

    // Récupère les détails d'une intention de paiement
    public static Intent retrievePaymentIntent(String paymentId) throws Exception {
        return yabetoo.payments.retrieve(paymentId);
    }
}

Utilisation de la méthode

Intent intentDetails = retrievePaymentIntent(payment.getId());
System.out.println("Statut : " + intentDetails.getStatus());

Exemple complet - Création, confirmation et récupération

import com.yabetoo.Yabetoo;
import com.yabetoo.models.*;
import com.yabetoo.models.ConfirmationResponse;

public class PaymentDemo {

    private static final Yabetoo yabetoo = new Yabetoo("sk_test_XXXXXXXXXXXXXXXXXXXXXXXX");

    public static void main(String[] args) {
        try {
            // 1. Créer une intention
            IntentCreateResponse payment = createPaymentIntent(20000, "xaf", "Commande #1234");
            System.out.println("Intention créée : " + payment.getId());

            // 2. Confirmer l’intention
            IntentConfirmationResponse confirmation = confirmPaymentIntent(
                    payment.getId(),
                    payment.getClientSecret()
            );
            System.out.println("Paiement confirmé : " + confirmation.getId());

            // 3. Récupérer les détails
            Intent intentDetails = retrievePaymentIntent(payment.getId());
            System.out.println("Statut du paiement : " + intentDetails.getStatus());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // Méthodes réutilisables
    public static IntentCreateResponse createPaymentIntent(int amount, String currency, String description) throws Exception {
        PaymentIntentRequest request = new PaymentIntentRequest(amount, currency, description, null);
        return yabetoo.payments.create(request);
    }

    public static IntentConfirmationResponse confirmPaymentIntent(String paymentId, String clientSecret) throws Exception {
        Momo momo = new Momo("cg", "242066594471", "mtn");
        PaymentMethodData paymentMethodData = new PaymentMethodData("momo", momo);
        PaymentConfirmationRequest request = new PaymentConfirmationRequest(clientSecret, "Loumbou", "Scoty", paymentMethodData);
        return yabetoo.payments.confirm(paymentId, request);
    }

    public static Intent retrievePaymentIntent(String paymentId) throws Exception {
        return yabetoo.payments.retrieve(paymentId);
    }
}

Grâce aux méthodes réutilisables, le SDK Java Yabetoo permet une gestion fluide et simplifiée des paiements en ligne. Cette structure garantit un code propre et maintenable pour gérer chaque étape du processus de paiement.