SDK Java

Ciblez l'URL de base de l'API la plus à jour

Pour créer des paiements, vous devez connecter votre serveur à notre plateforme via l'une de nos méthodes d'intégration.
Notre bibliothèque SDK Java est la solution idéale pour se connecter à notre plateforme si vous préférez le faire avec votre propre système autonome en utilisant le langage Java.

En choisissant le SDK Java, vous pouvez :

• Accéder à toutes les fonctionnalités de notre API RESTful de manière compacte, pratique et personnalisable.
• Utiliser toutes les méthodes d'intégration côté serveur de notre plateforme (Hosted Checkout Page / Hosted Tokenization Page / Server-to-server).
• Effectuer tous les appels API liés au traitement des paiements (c'est-à-dire CreateHostedCheckout, CreatePayment, RefundPayment et bien d'autres).

Pour tirer pleinement parti de ce SDK, assurez-vous de répondre à ces exigences :

• Java 8 ou supérieur
• Maven/Gradle

Téléchargez la version la plus récente de la bibliothèque Java et suivez les instructions d'installation. Vous pouvez télécharger et installer la dernière version du SDK Java par :

• Utilisation du Maven Repository
  Assurez-vous de sélectionner la dernière version.
  
  
• Utilisation de Gradle
  Assurez-vous de sélectionner la dernière version.
  
  
• Téléchargement du code source du SDK sur GitHub et installation de notre bibliothèque manuellement sur votre système.

Trouvez plus de détails sur GitHub. Consultez également tous les objets et propriétés SDK disponibles dans notre API Reference complète. Une fois que vous êtes prêt, lisez les chapitres suivants sur comment préparer et utiliser le SDK.

Initialisation

Pour connecter votre système à notre plateforme en utilisant le SDK, vous devez d'abord l'initialiser.

L'initialisation nécessite de :

• Créer un compte test/production.
• Créer un fichier de propriétés :
  

  
  onlinePayments.api.integrator=CompanyName
  onlinePayments.api.endpoint.host=ProperApiEndpoint
   # The properties below are optional and use the given values by default
  onlinePayments.api.endpoint.scheme=https
  onlinePayments.api.endpoint.port=-1
  onlinePayments.api.connectTimeout=10000
  onlinePayments.api.socketTimeout=10000
  onlinePayments.api.maxConnections=10
  onlinePayments.api.https.protocols=TLSv1.2
  onlinePayments.api.authorizationType=V1HMAC

• Créer une API Key et un API Secret pour le PSPID que vous souhaitez utiliser pour le traitement des transactions.
• Initialiser une instance de Client en utilisant la API Key / API Secret pour configurer la connexion à notre plateforme de test/production.

Après l'initialisation, vous pouvez commencer à traiter des transactions via votre PSPID. Découvrez comment cela fonctionne dans le chapitre dédié.

Consultez les exemples de code de deux méthodes de connexion couvrant les étapes mentionnées ci-dessus :

1. En utilisant le fichier de propriétés créé
   

   
   private ClientInterface client;
   
   private MerchantClientInterface merchantClient;
   
   public void initialiseSdk () {
       URI propertiesUri = Objects.requireNonNull(getClass().getClassLoader().getResource("paymentprovider.properties")).toURI();
       client = Factory.createClient(propertiesUri, "apiKey", "apiSecret");
       merchantClient = client.merchant("PSPID");
   }
   

2. En utilisant CommunicatorConfiguration
   

   
   CommunicatorConfiguration communicatorConfiguration = new CommunicatorConfiguration()
           .withApiKeyId("apiKey")
           .withSecretApiKey("apiSecret")
           .withApiEndpoint(URI.create("apiEndpoint"))
           .withIntegrator("integrator")
           .withAuthorizationType(AuthorizationType.V1HMAC);
   client = Factory.createClient(communicatorConfiguration);
   merchantClient  = client.merchant("PSPID");
   

Le tableau suivant fournit un aperçu des arguments acceptés par les instances individuelles :

Après avoir initialisé le SDK, vous pouvez envoyer des requêtes à notre plateforme via votre PSPID. Apprenez à le faire dans le prochain chapitre.

Utiliser le SDK

Après l'initialisation réussie de l'instance Client, vous obtenez un accès complet à notre API RESTful. Cela vous permet de :

• Envoyer des demandes pour de nouvelles transactions avec l'une de nos modes d'intégration serveur.
• Obtenir le statut actuel de vos transactions.
• Effectuer des demandes de maintenance (c'est-à-dire, capturer, rembourser) sur des transactions existantes.

Consultez nos cas de test sur GitHub, incluant des exemples de code complets, ainsi que notre API Reference complète pour découvrir ce qui est possible.

Ci-dessous, vous trouverez certaines des actions les plus courantes que vous pouvez effectuer :

• Créer de nouvelles transactions
• Obtenir le statut d'une transaction
• Effectuer une opération de maintenance

Créer de nouvelles transactions

Pour créer une nouvelle transaction, vous pouvez utiliser l'instance Client ou MerchantClient pour l'une de nos modes d'intégration pour créer une nouvelle transaction. Cela peut être fait par :

• Orientation de la demande vers votre PSPID sur notre plateforme (pour Client).
• Création d'une demande pour la méthode d'intégration respective.

Vous trouverez ci-dessous des exemples de code relatifs à des modes d'intégration spécifiques :

• Hosted Checkout Page
• Hosted Tokenization Page
• Server-to-server

Hosted Checkout Page

Pour utiliser cette méthode d'intégration, vous devez créer un appel CreateHostedCheckoutRequest. Il doit contenir au moins un objet Order.

/*
 *… Initialisation....
 */
CreateHostedCheckoutRequest checkoutRequest = new CreateHostedCheckoutRequest();

// The request with an example object of the AmountOfMoney
checkoutRequest.withOrder(new Order()
    .withAmountOfMoney(new AmountOfMoney()
        .withAmount(100L)
        .withCurrencyCode("EUR")));
CreateHostedCheckoutResponse response = merchantClient.hostedCheckout().createHostedCheckout(checkoutRequest);

Cet appel renvoie une réponse CreateHostedCheckout. Stockez le hostedCheckoutId et le RETURNMAC qu'il contient, ainsi que toutes les autres informations pertinentes pour vous. Vous aurez besoin de ces informations pour les étapes décrites dans les chapitres suivants.

Cette réponse contient également une partialRedirectUrl.

Vous devez concaténer l'URL de base "https://payment." avec partialRedirectUrl selon la formule

https://payment. + partialRedirectUrl

et rediriger votre client vers cette URL. Une fois que le client visite le Hosted Checkout Page, le processus de paiement se poursuit là-bas.

Hosted Tokenization Page

Pour utiliser cette méthode d'intégration, vous devez

• Créer et télécharger un modèle comme décrit dans notre guide Hosted Tokenization Page

CreateHostedTokenizationRequest hostedTokenizationRequest = new CreateHostedTokenizationRequest();
CreateHostedTokenizationRequest createHostedTokenizationRequest = hostedTokenizationRequest.withVariant("VotreTemplate.html"); 
CreateHostedTokenizationResponse hostedTokenizationResponse = merchantClient.hostedTokenization() 
        .createHostedTokenization(createHostedTokenizationRequest);

À partir de CreateHostedTokenizationResponse, récupérez hostedTokenizationId et partialRedirectUrl. Utilisez le partialRedirectUrl pour l'iframe et le hostedTokenizationId ou le tokenId (voir encadré) pour créer le paiement effectif via la méthode d'intégration Server-to-server.

GetHostedTokenizationResponse getHostedTokenizationResponse = initializer.getClientMerchant().hostedTokenization().getHostedTokenization(hostedTokenizationId);
String tokenId = getHostedTokenizationResponse.getToken().getId();

// L'objet d'exemple du AmountOfMoney 
AmountOfMoney amount = new AmountOfMoney() 
      .withAmount(100L) 
      .withCurrencyCode("EUR"); 

Order order = new Order().withAmountOfMoney(amount);
CardPaymentMethodSpecificInput paymentInput = new CardPaymentMethodSpecificInput().withToken(tokenId);

CreatePaymentRequest requestBody = new CreatePaymentRequest()
        .withCardPaymentMethodSpecificInput(paymentInput)
        .withOrder(order);
CreatePaymentResponse response = initializer.getClientMerchant().payments().createPayment(requestBody);

Server-to-server

Une CreatePaymetRequest minimale nécessite que vous définissiez au moins un objet Order et une méthode de paiement :

// L'objet d'exemple du AmountOfMoney 
AmountOfMoney amountOfMoney = new AmountOfMoney() 
        .withAmount(100L) 
        .withCurrencyCode("EUR"); 
Order order = new Order().withAmountOfMoney(amountOfMoney); 
 
// Pour obtenir plus de données de cartes de test, visitez le site web : Trouvez plus de données de test ici
Card card = new Card() 
         .withCvv("123") 
         .withCardNumber("5399999999999999") 
         .withCardholderName("Test Name") 
         .withExpiryDate("1236"); 
int paymentProductId = 3; 
 
PaymentsClientInterface paymentClient = merchantClient.payments(); 
CreatePaymentRequest createPaymentRequest = new CreatePaymentRequest(); 
 
CardPaymentMethodSpecificInput cardPaymentMethodSpecificInput = new CardPaymentMethodSpecificInput(); 
cardPaymentMethodSpecificInput.setCard(card); 
cardPaymentMethodSpecificInput.setPaymentProductId(paymentProductId) ; 
 
createPaymentRequest.setCardPaymentMethodSpecificInput(cardPaymentMethodSpecificInput); 
createPaymentRequest.setOrder(order); 
 
CreatePaymentResponse createPaymentResponse = paymentClient.createPayment(createPaymentRequest);

Obtenir le statut d'une transaction

Notre API RESTful vous permet de demander à tout moment le statut d'une transaction grâce à l'un de nos appels GET :

• GetHostedCheckout
• GetPaymentDetails
• GetCaptures
• GetRefunds

Une requête GetPaymentDetails ressemble à ceci :

PaymentResponse paymentResponse = merchantClient.payments().getPaymentDetails(paymentId);

Pour plus d'informations sur les statuts, visitez la page de documentation des statuts.

Effectuer une opération de maintenance

Pour effectuer des actions de suivi sur des transactions existantes (c'est-à-dire des captures ou des remboursements), utilisez respectivement notre appel API CapturePayment ou RefundPayment :

CapturePayment

/* 
/* 
 *… Initialisation....
 */

 // Here you get paymentId you can use in further code
 String paymentId = createPaymentResponse.getPayment().getId();
 CapturePaymentRequest capturePaymentRequest = new CapturePaymentRequest();
 capturePaymentRequest.withAmount(amount);
 capturePaymentRequest.setIsFinal(true);

 merchantClient.payments().capturePayment(paymentId, capturePaymentRequest);

RefundPayment

/*
 *… Initialisation....
 */

RefundRequest refundRequest = new RefundRequest();
// L'objet exemple de AmountOfMoney
AmountOfMoney amountOfMoney = new AmountOfMoney()
        .withAmount(100L)
        .withCurrencyCode("EUR");
refundRequest.setAmountOfMoney(amountOfMoney);
// Obtenir l'objet RefundResponse
RefundResponse refundResponse = merchantClient.payments().refundPayment(paymentId, refundRequest);

Gérer les exceptions

Si une transaction est rejetée, notre plateforme fournit des informations détaillées avec une instance d'Exception. Le code d'état HTTP associé vous aide également à résoudre l'erreur.

Vous pouvez rencontrer deux types d'exceptions : exceptions de transaction et exceptions HTTP.

Exceptions de transaction

Ce type d'exception se réfère aux demandes de transaction qui sont techniquement correctes mais qui ont été rejetées par l'émetteur de votre client ou votre acquéreur. Si la transaction est renvoyée dans l'exception, cela signifie qu'elle a été créée dans nos systèmes mais n'a pas été traitée avec succès.

/*
 * Initialisation....
 */
        
CreatePaymentRequest createPaymentRequest = new CreatePaymentRequest();
String paymentId;
try {
    CreatePaymentResponse createPaymentResponse = merchantClient.payments().createPayment(createPaymentRequest);
    paymentId = createPaymentResponse.getPayment().getId();
} catch (DeclinedPaymentException e) {

    PaymentResponse payment = e.getCreatePaymentResponse().getPayment();
    paymentId = payment.getId();
    String paymentStatus = payment.getStatus();
    handleError(payment);
}
PaymentResponse paymentResponse = merchantClient.payments().getPayment(paymentId);

// Votre code pour vérifier le statut de la transaction et gérer les erreurs 
if (isNotSuccessful(paymentResponse)) {
    handleError(paymentResponse);
}

/*
 * Initialisation....
 */

String paymentId = createPaymentResponse.getPayment().getId();
String refundId;

RefundRequest refundRequest = new RefundRequest();

try {
    RefundResponse refundResponse = merchantClient.payments().refundPayment(paymentId, refundRequest);
    refundId = refundResponse.getId();
} catch (DeclinedRefundException e) {
    RefundResponse refundResult = e.getRefundResponse();
    refundId = refundResult.getId();
    handleError(refundResult);
}
RefundsResponse refundResponse = merchantClient.payments().getRefunds(paymentId);

// Votre code pour vérifier le statut de la transaction et gérer les erreurs 
if (isNotSuccessful(refundResponse, refundId)) {
    handleError(refundResponse);
} 

Exceptions HTTP

Ce type d'exception se réfère à divers problèmes causés par des erreurs techniques lors de l'appel API ou de la demande de paiement.

Vous pouvez combiner n'importe lequel des extraits de code suivants avec cette demande standard CreatePayment :

/* 
 *… Initialisation….
 */

CreatePaymentRequest createPaymentRequest = new CreatePaymentRequest(); 
// L'objet exemple de AmountOfMoney 
AmountOfMoney amountOfMoney = new AmountOfMoney() 
        .withAmount(100L) 
        .withCurrencyCode("EUR"); 

Order order = new Order().withAmountOfMoney(amountOfMoney); 

CardPaymentMethodSpecificInput cardPaymentMethodSpecificInput = new CardPaymentMethodSpecificInput(); 

// L'objet exemple de la Card – vous pouvez trouver des cartes de test sur /documentation/test-cases/ 
Card card = new Card() 
         .withCvv("123") 
         .withCardNumber("5399999999999999") 
         .withCardholderName("Test Name") 
         .withExpiryDate("1236"); 

cardPaymentMethodSpecificInput.setCard(card); 
cardPaymentMethodSpecificInput.setPaymentProductId(3); 

createPaymentRequest.setCardPaymentMethodSpecificInput(cardPaymentMethodSpecificInput); 

try { 
    CreatePaymentResponse createPaymentResponse = paymentClient.createPayment(createPaymentRequest); 
} 
catch (ApiException e) { 
    // Reportez-vous à la liste ci-dessous pour voir comment gérer des implémentations spécifiques de ApiException. 
}

catch (ValidationException e) {
    System.err.println("Erreur de validation des entrées");
    for (APIError error : e.getErrors()) {
        if (error.getPropertyName() == null) {
            System.err.println(error.getErrorCode() + ": " + error.getMessage());
        } else {
            System.err.println(error.getPropertyName() + ": " + error.getErrorCode() + ": " + error.getMessage());
        }
    }
}

catch (AuthorizationException e) {
    System.err.println("Erreur d'autorisation");
    for (APIError error : e.getErrors()) {
        System.err.println(error.getErrorCode() + ": " + error.getMessage());
    }
}

catch (IdempotenceException e) {
    System.err.println("Erreur d'idempotence :");
    for (APIError error : e.getErrors()) {
        System.err.println(error.getErrorCode() + ": " + error.getMessage());
    }
}

catch (ReferenceException e) {
    System.err.println("Référence d'objet incorrecte :");
    for (APIError error : e.getErrors()) {
        System.err.println(error.getErrorCode() + ": " + error.getMessage());
    }
}

catch (PlatformException e) {
    System.err.println("Une erreur est survenue sur la plateforme de paiement ou chez un partenaire/acquéreur en aval :");
    for (APIError error : e.getErrors()) {
        System.err.println(error.getErrorCode() + ": " + error.getMessage());
    }
}

catch (ApiException e) {
    System.err.println("Erreur de plateforme : ");
    for (APIError error : e.getErrors()) {
        System.err.println(error.getErrorCode() + ": " + error.getMessage());
    }
}

catch (CommunicationException e) { 
    System.err.println("Erreur de communication : " + e.getMessage()); 
}

Codes de statut HTTP

Toutes nos exceptions sont liées à un ou plusieurs codes de statut HTTP, indiquant la cause première de nombreuses erreurs possibles.

IdempotenceException
ReferenceException

ReferenceException

PlatformException

PlatformException

PlatformException

ApiException

Fonctionnalités supplémentaires

Le SDK a beaucoup plus à offrir. Consultez les fonctionnalités suivantes, car elles vous aideront à créer la solution parfaite.

• Obtenez les méthodes de paiement disponibles
• Envoyer des requêtes idempotentes
• Utiliser la logging
• Regroupement de connexions
• Personnaliser la communication
• Webhooks

Obtenez les méthodes de paiement disponibles

Avant de lancer le processus de paiement réel, vous envoyez une requête GetPaymentProducts à notre plateforme. La réponse contient une liste des méthodes de paiement disponibles dans votre PSPID. Selon les préférences de vos clients, vous pouvez proposer une sélection sur notre Hosted Checkout Page ou sur l'environnement de votre propre boutique en ligne en utilisant des demandes CreatePayment ultérieures.

/*
 *…. Initialisation....
 */

// Prepare the request to get all active payment methods in your PSPID
GetPaymentProductsParams queryParams = new GetPaymentProductsParams()
    .withCountryCode("FR")
    .withCurrencyCode("EUR");

// Send the request and get the response
GetPaymentProductsResponse paymentProductResponse = merchantClient.products().getPaymentProducts(queryParams);

Envoyer des requêtes idempotentes

L'une des principales fonctionnalités de l'API REST est sa capacité à détecter et à empêcher l'envoi accidentel de requêtes (par exemple, des demandes de paiement) deux fois. Le SDK vous facilite grandement la tâche pour vous assurer que vous n'envoyez que des requêtes uniques – idempotentes – à notre plateforme.

Utilisez l'argument supplémentaire paymentContext et définissez sa propriété nommée idempotence dans une requête CreatePayment. Le SDK enverra un en-tête X-GCS-Idempotence-Key avec la clé d'idempotence comme valeur.

Si vous envoyez des requêtes de cette manière à notre plateforme, nous vérifierons ce qui suit :

• Si vous envoyez une requête ultérieure avec la même clé d'idempotence, la réponse contient un en-tête X-GCS-Idempotence-Request-Timestamp. Le SDK définira la propriété idempotenceRequestTimestamp de l'argument paymentContext.
• Si la première requête n'est pas encore terminée, l'API RESTful Server renvoie un code d'état 409. Ensuite, le SDK génère une IdempotenceException avec la clé d'idempotence d'origine et l'horodatage de la demande d'idempotence.

/*
 *…. Initialisation....
 */

CreatePaymentRequest createPaymentRequest = new CreatePaymentRequest();

String idempotenceKey = "YourKeyForThePayment";

CallContext callContext = new CallContext();
callContext.withIdempotenceKey(idempotenceKey);

try {
    CreatePaymentResponse createPaymentResponse = merchantClient.payments().createPayment(createPaymentRequest, callContext);
} catch (IdempotenceException e) {
    // a request with the same idempotenceKey is still in progress, try again after a short pause
    // e.getIdempotenceRequestTimestamp() contains the value of the
    // X-GCS-Idempotence-Request-Timestamp header
} finally {
    Long idempotenceRequestTimestamp = callContext.getIdempotenceRequestTimestamp();
    // idempotenceRequestTimestamp contains the value of the
    // X-GCS-Idempotence-Request-Timestamp header
    // if idempotenceRequestTimestamp is not empty, this was not the first request
}

Utiliser la Logging

Le SDK prend en charge la Logging des requêtes, des réponses et des exceptions de la communication API. Cela peut être utile pour résoudre les problèmes ou suivre les étapes individuelles du flux de paiement.

Pour utiliser cette fonctionnalité de Logging, vous devez implémenter l'interface CommunicatorLogger.

Le SDK offre deux implémentations de la fonctionnalité de Logging :

• System.out (SysOutCommunicatorLogger)
• java.util.logging.Logger (JdkCommunicatorLogger)

Vous pouvez activer/désactiver la Logging en appelant la méthode enableLogging sur un objet ClientInterface et en fournissant le journal comme argument. Vous pouvez ensuite désactiver le journal en appelant la méthode disableLogging :

ClientInterface client = Factory.createClient(propertiesUrl.toURI(), "apiKeyId", "secretApiKey");

CommunicatorLogger logger = new JdkCommunicatorLogger(Logger.getLogger(...), Level.INFO);
client.enableLogging(logger);
//... Effectuer quelques appels
client.disableLogging();

Regroupement de connexions

Vous pouvez gérer vos ressources réseau en limitant le nombre de connexions possibles que le SDK crée et maintient. Les instances de Client créées comme discuté dans le chapitre Initialiser le SDK auront leur propre pool de connexions. Les instances de Client créées avec le même objet Communicator partagent un pool de connexions.

Si vous utilisez plusieurs instances de Client pour partager un seul pool de connexions, assurez-vous de suivre ces étapes :

1. Créez un Communicator partagé. Vous pouvez utiliser la classe com.onlinepayments.Factory.
2. Créez des instances de Client avec ce Communicator.

/* 
 *…. Initialisation....
 */

/* Initialisation... */  
// Instance de Communicator 


Communicator communicator = Factory.createCommunicator(propertiesUrl.toURI(), "apiKeyId", "secretApiKey"); 
// créez un ou plusieurs clients en utilisant le communicateur partagé 
ClientInterface client = Factory.createClient(communicator); 

Personnaliser la communication

Un ClientInterface utilise un Communicator pour communiquer avec notre plateforme. Les implémentations de Communicator transforment un objet de demande en une demande HTTP et une réponse HTTP en un objet de réponse. Si nécessaire, vous pouvez étendre cette classe. Pour instancier un ClientInterface qui utilise votre propre implémentation de Communicator, vous pouvez utiliser l'extrait de code suivant :

Communicator communicator = new YourCommunicator();
ClientInterface client = Factory.createClient(communicator);

Fournir votre propre implémentation n'est pas nécessaire dans la plupart des cas. La fonctionnalité du com.onlinepayments.defaultimpl.DefaultCommunicator est construite sur les classes : Authenticator, Connection, Marshaller et MetadataProvider. L'implémentation de ces classes peut facilement être étendue ou remplacée pour répondre à vos besoins.

Marshaller est utilisé pour sérialiser / désérialiser les objets de demande et de réponse vers et depuis JSON, ce que vous ne devriez pas changer. Les autres modules nécessaires pour communiquer avec notre plateforme sont :

• Le URI de la API endpoint RESTful Server.
• Une Connection pour une ou plusieurs connexions HTTP à notre serveur.
• Un Authenticator, pour signer vos demandes.
• Un MetadataProvider, construisant l'en-tête avec les métadonnées de votre serveur.

Pour votre commodité, la classe CommunicatorBuilder est fournie pour remplacer facilement un ou plusieurs de ces modules. Par exemple, pour instancier un ClientInterface qui utilise votre propre implémentation de Connection, vous pouvez utiliser l'extrait de code suivant :

/* 
 *…. Initialisation....
 */

Connection connection = new YourConnection();  
Communicator communicator = Factory.createCommunicatorBuilder(propertiesUrl.toURI(), "apiKeyId", "secretApiKey").withConnection(connection).build();  
ClientInterface client = Factory.createClient(communicator);

Webhooks

La partie du SDK qui gère la prise en charge des webhooks s'appelle le helper de webhooks. Il gère de manière transparente la validation des signatures par rapport aux corps des événements envoyés par le système de webhooks (y compris la recherche de la clé secrète pour les ID de clé - à ne pas confondre avec l'API Key et le API secret), et la désérialisation de ces corps en objets. Cela vous permet de vous concentrer sur l'essentiel, sans passer par toutes les informations supplémentaires et extraire les informations souhaitées vous-même. Pour en savoir plus sur les webhooks, lisez notre guide dédié. 

Fournir des clés secrètes

Configurez le "WebhooksKey" / "WebhooksKeySecret" et les API endpoints des webhooks de votre serveur dans le Merchant Portal:

String keyId = "WebhooksKey";
String secretKey = "WebhooksKeySecret";

Utilisez InMemorySecretKeyStore.INSTANCE.storeSecretKey(keyId, secretKey) pour stocker une clé secrète pour un ID de clé.

Vous pouvez ajouter ou supprimer des clés à l'aide des fonctions suivantes :

• InMemorySecretKeyStore.INSTANCE.getSecretKey(keyId)
• InMemorySecretKeyStore.INSTANCE.removeSecretKey(keyId) pour supprimer la clé secrète stockée pour un ID de clé.
• InMemorySecretKeyStore.INSTANCE.clear() pour supprimer toutes les clés secrètes stockées.

Si vous avez besoin d'un stockage plus avancé, par exemple en utilisant une base de données ou un système de fichiers, nous vous recommandons de rédiger votre propre implémentation.

Initialiser le helper de webhooks

En utilisant une implémentation de com.onlinepayments.webhooks.SecretKeyStore, créez une instance de com.onlinepayments.webhooks.WebhooksHelper :

WebhooksHelper helper = new WebhooksHelper(DefaultMarshaller.INSTANCE, InMemorySecretKeyStore.INSTANCE)

Utiliser le helper de Webhooks

Pour traiter les événements reçus dans un webhook, commencez par appeler la méthode unmarshal de l'objet WebhooksHelper. Cela prend les arguments suivants :

• Le corps, sous forme de chaîne. Cela devrait être le corps brut tel que reçu du système de webhooks.

  String bodyOfRequest = "JSON_Body_Of_The_Request";

• Une liste d'en-têtes de requête tels que reçus du système de webhooks. Vous trouverez ci-dessous un exemple de création d'une liste d'en-têtes de requête. Elle doit contenir les deux en-têtes pour le keyId et la signature :
  
  

  // Récupérez les en-têtes du message Webhook, dépend de votre implémentation.
  List<Header> webhookHeaders = request.getHeaders();
  
  // Transformez les en-têtes reçus
  List<RequestHeader> requestHeaders = new ArrayList<RequestHeader>();
  for (Header webhookHeader : webhookHeaders) {
      requestHeaders.add(new RequestHeader(webhookHeader.getName(), webhookHeader.getValue()));
  }

• Vous pouvez maintenant utiliser le helper de webhook pour démystifier les événements entrants qui vous permettent de traiter les données dans votre application :
  
  

  try {
      WebhooksEvent event = helper.unmarshal(bodyOfRequest, requestHeaders);
  } catch (SignatureValidationException e) {
      // Votre code pour gérer l'erreur
  }