Établir la connectivité avec les API Payments dans Node.js

1. Avant de commencer

Cet atelier de programmation autonome vous explique comment établir une connectivité avec les API Standard Payments.

Prérequis

  • Vous avez terminé les étapes 1 et 2 du processus d'implémentation.
  • Vous pouvez héberger le serveur Node.js fourni avec terminaison TLS en utilisant Google App Engine ou votre propre solution au niveau du domaine configuré avec Google.
  • Node.js est installé dans votre environnement.

Ce que vous allez apprendre

  • Comment vérifier la connectivité en envoyant une requête valide à l'API Google Standard Payments echo.
  • Découvrez comment recevoir, déchiffrer et analyser une requête envoyée par Google à l'API Partner Hosted Echo.

2. Préparation

Télécharger l'application

Téléchargez l'exemple de code Node.js.

Installer des dépendances

Accédez au répertoire du projet et exécutez la commande suivante pour installer les dépendances requises. Si vous utilisez App Engine, vous pouvez ignorer cette étape.

npm install

3. Configurer l'ID de compte de l'intégrateur de paiement (PIAID)

L'ID de compte de l'intégrateur de paiement (PIAID) est un identifiant utilisé pour identifier de manière unique vos intégrations. Vous devriez avoir reçu votre PIAID de Google en remplissant les conditions préalables avant de commencer ce tutoriel.

  1. Accédez au fichier server.js dans le répertoire du projet.
  2. Définissez la variable PIAID sur le PIAID qui vous a été attribué par Google.
const PIAID = '{PAYMENT_INTEGRATOR_ACCOUNT_ID}';

4. Ajouter des clés PGP

Créez les fichiers suivants dans la structure du projet et ajoutez vos clés PGP pour activer le chiffrement PGP.

  • Créez un fichier nommé public.key et ajoutez-y la clé publique au format ASCII.
  • Créez un fichier nommé private.key et ajoutez-y la clé privée au format ASCII.
  • Créez un fichier nommé passphrase.txt et ajoutez-y la phrase secrète.

Ajouter des clés PGP

Parfait, vous êtes prêt à exécuter l'application.

5. Exécuter l'application

Pour démarrer l'application, exécutez la commande suivante.

$ node server.js
Server listening on port 8080...

Si vous exécutez une instance App Engine préconfigurée, exécutez plutôt cette commande.

$ gcloud app deploy

Par défaut, le serveur écoute sur le port 8080.

6. Tester la connectivité de l'API Google Standard Payments

Maintenant que l'application est en cours d'exécution, il est temps de tester la connectivité avec l'API Echo de Google Standard Payments.

Exécutez la commande suivante pour lancer un appel depuis votre instance de l'exemple d'application vers les serveurs de Google. L'exemple d'API d'écho d'application accepte une requête POST en texte brut. Une fois la requête reçue, une requête ultérieure est envoyée à l'API hébergée par Google.

  $ curl -X POST -H 'Content-Type: text/plain' -d 'Hello from Little Bear' https://{HOSTNAME}/echo

Une requête d'API réussie génère la réponse suivante de Google.

{
   "responseHeader":{
      "responseTimestamp":"1606710026723"
   },
   "clientMessage":"Hello from Little Bear",
   "serverMessage":"Server message."
}

Pas-à-pas

Maintenant qu'une requête a été envoyée par votre serveur, examinons comment cela a fonctionné.

Créer la demande

buildEchoRequestBody dans bodyHelpers.js crée la requête echo envoyée à l'API de Google.

const message = bodyHelpers.buildEchoRequestBody(req.body);

La requête générée inclut clientMessage, ainsi que plusieurs champs de valeurs par défaut.

{
   "requestHeader":{
      "protocolVersion":{
         "major":1,
         "minor":0,
         "revision":0
      },
      "requestId":"ddfe0fd0-ffdc-4fcf-991a-f0611ec83970",
      "requestTimestamp":"1606715389040"
   },
   "clientMessage":"Hello from Little Bear"
}

Chiffrer la demande

Toutes les requêtes sont chiffrées et encodées en base64url. Dans cet exemple, crypto.js contient des méthodes d'assistance qui effectuent le chiffrement et le déchiffrement pour vous. La méthode crypto.encrypt effectue le chiffrement à l'aide de la clé publique de Google.

const encrypted = await crypto.encrypt(message);

Envoyer la requête POST encodée en base64url

Le message chiffré est encodé en base64url à l'aide du package base64url et envoyé via une requête POST à l'aide d'axios.

const response = await axios.post(ECHO_URL, base64url(encrypted), AXIOS_CONFIG);

Déchiffrer et renvoyer la réponse

La réponse de Google est encodée et chiffrée en base64url. Elle doit donc également être décodée et déchiffrée avant de pouvoir être renvoyée en texte brut.

const encryptedMessage = base64url.toBuffer(response.data);
const decryptedResponse = await crypto.decrypt(encryptedMessage);
res.status(200);
res.send(decryptedResponse);

7. Tester la connectivité de l'API Partner

Pour tester la connectivité de l'API Echo du partenaire, Google enverra une requête à l'API Echo hébergée par le partenaire.

Lorsque vous serez prêt, veuillez contacter votre point de contact Google pour déclencher cette demande depuis Google.

Le test d'écho est terminé lorsque vous pouvez lire la demande d'écho entrante de Google et y répondre avec une réponse d'écho valide.

Pas-à-pas

Maintenant qu'une requête a été reçue et traitée par votre serveur, examinons comment cela s'est passé.

Décodez la requête en base64url.

Lorsque vous recevez la requête, vous devez d'abord la décoder en base64url.

const encryptedRequest = base64url.toBuffer(req.body);

Déchiffrer la demande

Une fois la demande décodée en base64url, vous devez la déchiffrer.

const decryptedRequest = await crypto.decrypt(encryptedRequest);

Recevoir la demande

Une fois décodée et déchiffrée, la charge utile du message envoyé par Google ressemble à ce qui suit.

{
  "requestHeader": {
    "protocolVersion": {
      "major": 1
    },
    "requestId": "G1MQ0YERJ0Q7LPM",
    "requestTimestamp": {
      "epochMillis":1481899949606
    },
    "paymentIntegratorAccountId": "abcdef123456"
  },
  "clientMessage": "echo Me"
}

Créer la réponse

Une fois que vous avez lu la demande d'écho entrante, vous êtes prêt à créer la réponse.

clientMessage = JSON.parse(decryptedRequest).clientMessage;
responseBody = bodyHelpers.buildEchoResponseBody(clientMessage);

La réponse inclut le message de Google, ainsi qu'un code temporel et un message du serveur.

{
  "responseHeader": {
    "responseTimestamp": {
      "epochMillis":1481899950236
    }
  },
  "clientMessage": "echo Me",
  "serverMessage": "Debug ID 12345"
}

Chiffrer et encoder la réponse en base64

Une fois le message de réponse créé, vous pouvez l'encrypter et l'encoder en base64url.

encryptedResponse = await crypto.encrypt(responseBody);
const encodedResponse = base64url(encryptedResponse);

Renvoyer la réponse

Enfin, vous êtes prêt à envoyer la réponse POST.

res.send(encodedResponse);

8. Félicitations !

Dans cet atelier de programmation, vous avez réussi à établir la connectivité avec l'API Echo.