Integration serveur a serveur

La solution serveur a serveur permet l'echange direct de donnees de transaction entre votre serveur et la plateforme de paiement Worldline. Cela vous donne un controle total sur l'experience client tout en gerant les paiements directement.

Avantages

• Controle total - Concevez votre propre page de paiement
• Experience fluide - Les clients restent dans votre environnement
• Flexibilite - Personnalisation complete du flux de paiement

Conformite PCI DSS

Cette methode implique la manipulation de donnees de carte, ce qui necessite la conformite PCI DSS. Envisagez d'utiliser la Tokenisation hebergee pour reduire significativement votre perimetre PCI.

Prerequis

Avant d'implementer cette integration, assurez-vous d'avoir :

1. Un compte Worldline Direct actif
2. Au moins une methode de paiement activee dans le Portail Marchand
3. Une cle API et un secret API configures
4. La conformite PCI DSS (si vous manipulez directement les donnees de carte)
5. Un serveur capable de traiter les requetes API RESTful

Flux d'integration

Implementation etape par etape

Etape 1 : Initialiser le SDK

Configurez votre SDK serveur avec vos identifiants :

C#

var configuration = new CommunicatorConfiguration
{
    ApiEndpoint = new Uri("https://payment.preprod.direct.worldline-solutions.com"),
    AuthorizationType = AuthorizationType.V1HMAC,
    ApiKeyId = "YOUR_API_KEY",
    SecretApiKey = "YOUR_API_SECRET"
};

var client = Factory.CreateClient(configuration);

Java

CommunicatorConfiguration configuration = new CommunicatorConfiguration()
    .withApiEndpoint(URI.create("https://payment.preprod.direct.worldline-solutions.com"))
    .withAuthorizationType(AuthorizationType.V1HMAC)
    .withApiKeyId("YOUR_API_KEY")
    .withSecretApiKey("YOUR_API_SECRET");

Client client = Factory.createClient(configuration);

PHP

$communicatorConfiguration = new CommunicatorConfiguration(
    'YOUR_API_KEY',
    'YOUR_API_SECRET',
    'https://payment.preprod.direct.worldline-solutions.com',
    'OnlinePayments'
);

$client = Factory::createClient($communicatorConfiguration);

Points d'acces des environnements :

Environnement	URL
Test	https://payment.preprod.direct.worldline-solutions.com
Production	https://payment.direct.worldline-solutions.com

Etape 2 : Creer une requete de paiement

Collectez les informations de carte depuis votre page de paiement et envoyez une requete CreatePayment :

C#

var body = new CreatePaymentRequest
{
    Order = new Order
    {
        AmountOfMoney = new AmountOfMoney
        {
            Amount = 2980,
            CurrencyCode = "EUR"
        },
        Customer = new Customer
        {
            MerchantCustomerId = "customer123",
            ContactDetails = new ContactDetails
            {
                EmailAddress = "customer@example.com"
            },
            BillingAddress = new Address
            {
                CountryCode = "NL",
                City = "Amsterdam"
            }
        },
        References = new OrderReferences
        {
            MerchantReference = "order-12345"
        }
    },
    CardPaymentMethodSpecificInput = new CardPaymentMethodSpecificInput
    {
        PaymentProductId = 1, // Visa
        Card = new Card
        {
            CardNumber = "4111111111111111",
            Cvv = "123",
            ExpiryDate = "1225",
            CardholderName = "John Doe"
        },
        ThreeDSecure = new ThreeDSecure
        {
            RedirectionData = new RedirectionData
            {
                ReturnUrl = "https://yoursite.com/return"
            }
        }
    }
};

var response = await client.WithNewMerchant("YOUR_MERCHANT_ID")
    .Payments
    .CreatePaymentAsync(body);

Java

CreatePaymentRequest body = new CreatePaymentRequest();

// Montant
AmountOfMoney amountOfMoney = new AmountOfMoney();
amountOfMoney.setAmount(2980L);
amountOfMoney.setCurrencyCode("EUR");

// Commande
Order order = new Order();
order.setAmountOfMoney(amountOfMoney);

OrderReferences references = new OrderReferences();
references.setMerchantReference("order-12345");
order.setReferences(references);

body.setOrder(order);

// Details de la carte
CardPaymentMethodSpecificInput cardInput = new CardPaymentMethodSpecificInput();
cardInput.setPaymentProductId(1); // Visa

Card card = new Card();
card.setCardNumber("4111111111111111");
card.setCvv("123");
card.setExpiryDate("1225");
card.setCardholderName("John Doe");
cardInput.setCard(card);

// 3-D Secure
ThreeDSecure threeDSecure = new ThreeDSecure();
RedirectionData redirectionData = new RedirectionData();
redirectionData.setReturnUrl("https://yoursite.com/return");
threeDSecure.setRedirectionData(redirectionData);
cardInput.setThreeDSecure(threeDSecure);

body.setCardPaymentMethodSpecificInput(cardInput);

CreatePaymentResponse response = client
    .withNewMerchant("YOUR_MERCHANT_ID")
    .payments()
    .createPayment(body);

Etape 3 : Gerer la reponse

La reponse inclut un objet merchantAction qui indique la prochaine etape :

{
  "payment": {
    "id": "000000123400000012340000100001",
    "status": "PENDING_AUTHENTICATION",
    "statusOutput": {
      "statusCode": 50
    }
  },
  "merchantAction": {
    "actionType": "REDIRECT",
    "redirectData": {
      "redirectURL": "https://issuer-bank.com/3ds/authenticate"
    }
  }
}

Scenario	merchantAction.actionType	Prochaine etape
3DS sans friction	null	Transaction terminee, verifier le statut
Challenge 3DS	REDIRECT	Rediriger le client vers l'URL
Sans 3DS	null	Transaction terminee, verifier le statut

Etape 4 : Gerer 3-D Secure (si requis)

Si actionType est REDIRECT, redirigez le client vers l'URL d'authentification :

if (response.merchantAction?.actionType === 'REDIRECT') {
    window.location.href = response.merchantAction.redirectData.redirectURL;
}

Apres l'authentification, le client revient a votre returnUrl.

Etape 5 : Recuperer le statut du paiement

Apres le retour du client, recuperez le statut final du paiement :

C#

var paymentDetails = await client.WithNewMerchant("YOUR_MERCHANT_ID")
    .Payments
    .GetPaymentDetailsAsync(paymentId);

var statusCode = paymentDetails.StatusOutput.StatusCode;

Java

PaymentDetailsResponse paymentDetails = client
    .withNewMerchant("YOUR_MERCHANT_ID")
    .payments()
    .getPaymentDetails(paymentId);

Integer statusCode = paymentDetails.getStatusOutput().getStatusCode();

Etape 6 : Afficher les resultats

Gerez le statut du paiement de maniere appropriee :

Code de statut	Signification	Action
0-99	En attente	Afficher le message de traitement
100-199	Autorise	Confirmer la commande, capturer plus tard
500-599	Rejete	Afficher l'erreur, proposer de reessayer
800-899	Capture	Confirmer et executer la commande

Utilisation des tokens

Reduisez le perimetre PCI en utilisant des tokens au lieu des donnees de carte brutes :

Tokens permanents (Carte enregistree)

Stockez les cartes des clients pour les achats futurs :

CardPaymentMethodSpecificInput = new CardPaymentMethodSpecificInput
{
    Token = "stored_token_from_previous_transaction"
}

Tokens temporaires (Tokenisation hebergee)

Utilisez des tokens temporaires de la Page de tokenisation hebergee :

CardPaymentMethodSpecificInput = new CardPaymentMethodSpecificInput
{
    Token = "temporary_token_from_tokenization"
}

Approche recommandee

L'utilisation de tokens reduit significativement vos exigences de conformite PCI DSS tout en maintenant une experience de paiement fluide.

Webhooks

Implementez les webhooks pour des notifications de statut de paiement fiables :

[HttpPost("webhook")]
public IActionResult HandleWebhook([FromBody] WebhookEvent webhookEvent)
{
    var payment = webhookEvent.Payment;
    var paymentId = payment.Id;
    var statusCode = payment.StatusOutput.StatusCode;

    // Mettre a jour le statut de la commande dans votre base de donnees
    UpdateOrderStatus(paymentId, statusCode);

    return Ok();
}

Important

Les webhooks sont asynchrones. Utilisez-les toujours comme mecanisme de notification de secours, pas pour les decisions de paiement en temps reel.

Bonnes pratiques

1. Utiliser les tokens - Minimisez le perimetre PCI en utilisant la tokenisation
2. Implementer 3-D Secure - Incluez toujours les proprietes 3DS pour les paiements par carte
3. Inclure l'email du client - Requis pour le suivi des conversions dans MyPerformance
4. Utiliser des references coherentes - Gardez merchantReference coherent pour les analyses
5. Gerer tous les statuts - Implementez une gestion appropriee pour tous les resultats possibles
6. Configurer les webhooks - Ne comptez jamais uniquement sur les redirections de retour

SDKs client

Pour collecter les informations de carte cote client :

Plateforme	SDK
JavaScript	GitHub
iOS (Swift)	GitHub
Android	GitHub
Flutter	pub.dev
React Native	npm

Prochaines etapes

• Configurer les webhooks pour des notifications fiables
• Implementer 3-D Secure pour une securite renforcee
• Explorer les moyens de paiement pour activer plus d'options