PayPal
PayPal-Zahlung durchführen

Parameter

Bemerkungen

Beispiel für einen Node Express Server

In diesem Beispiel richten wir eine Express-Server-Integration ein, um anzuzeigen, wie eine Zahlung mit PayPal mithilfe des PayPal Node SDK verarbeitet wird. Der Einfachheit halber verwenden wir eine statische JSON-Struktur für die Zahlungsdetails.

Es gibt drei allgemeine Schritte, die wir beim Ausarbeiten der Funktionen zur Abwicklung der PayPal-Zahlung befolgen werden:

1. Wir erstellen ein JSON-Objekt, das die Zahlung enthält, die wir über PayPal verarbeiten möchten. Wir senden das dann an PayPal, um einen Link zu erhalten, an den der Benutzer weitergeleitet werden kann, um die Zahlung zu bestätigen.
2. Als Nächstes leiten wir den Benutzer zu PayPal, um die Zahlung zu bestätigen. Nach der Bestätigung leitet PayPal den Benutzer zurück zu unserer Anwendung.
3. Nach der Rückkehr zur App führen wir die Zahlung für den Benutzer durch.

Um es als einfache Node-App aufzuteilen, erhalten wir zunächst das PayPal-Node-SDK von NPM:

npm install paypal-rest-sdk

Als Nächstes richten wir die App-Konfiguration und die Pakete ein.

var http = require('http'),
    paypal = require('paypal-rest-sdk'),
    bodyParser = require('body-parser'),
    app = require('express')();

var client_id = 'YOUR APPLICATION CLIENT ID';
var secret = 'YOUR APPLICATION SECRET';

//allow parsing of JSON bodies
app.use(bodyParser.json());

//configure for sandbox environment
paypal.configure({
    'mode': 'sandbox', //sandbox or live
    'client_id': client_id,
    'client_secret': secret
});

Wir benötigen vier Voraussetzungen für diese App:

1. Das HTTP-Paket für unseren Server.
2. Das PayPal-Node-SDK-Paket.
3. Das bodyParser-Paket für die Arbeit mit JSON-codierten Körpern.
4. Das Express-Framework für unseren Server.

In den nächsten Zeilen werden Variablen für die Client-ID und das Geheimnis eingerichtet, die beim Erstellen einer Anwendung abgerufen wurden. Dann richten wir bodyParser , um JSON-codierte Körper zuzulassen, konfigurieren dann unsere Anwendung anhand der Anwendungsdetails und geben die Umgebung an, in der wir arbeiten (live für die Produktion oder Sandbox zum Testen).

Nun erstellen wir die Route zum Erstellen einer Zahlungsanforderung mit PayPal.

app.get('/create', function(req, res){
    //build PayPal payment request
    var payReq = JSON.stringify({
        'intent':'sale',
        'redirect_urls':{
            'return_url':'http://localhost:3000/process',
            'cancel_url':'http://localhost:3000/cancel'
        },
        'payer':{
            'payment_method':'paypal'
        },
        'transactions':[{
            'amount':{
                'total':'7.47',
                'currency':'USD'
            },
            'description':'This is the payment transaction description.'
        }]
    });

    paypal.payment.create(payReq, function(error, payment){
        if(error){
            console.error(error);
        } else {
            //capture HATEOAS links
            var links = {};
            payment.links.forEach(function(linkObj){
                links[linkObj.rel] = {
                    'href': linkObj.href,
                    'method': linkObj.method
                };
            })
        
            //if redirect url present, redirect user
            if (links.hasOwnProperty('approval_url')){
                res.redirect(links['approval_url'].href);
            } else {
                console.error('no redirect URI present');
            }
        }
    });
});

Als Erstes richten wir das JSON-Objekt für die Zahlungsanforderung ein, das die Informationen enthält, die PayPal zur Erstellung der Zahlung angeben müssen. Wir setzen die intent sale , die Redirect URLs angeben (wo PayPal die Benutzer weitergeleitet werden soll , nachdem sie bestätigen / die Zahlung stornieren), fügen Sie in einem payment_method von paypal , um zu signalisieren , dass wir eine PayPal - Zahlung leisten, dann geben Sie die Transaktionsinformationen für der Zahler zur Bestätigung.

Wir rufen dann payment.create(...) und übergeben unser payReq Objekt. Dadurch wird die erstellte Zahlungsanforderung an PayPal gesendet. Sobald dies zurückkehrt und erfolgreich ist, können wir die bereitgestellten HATEOAS- Links im Rückgabeobjekt durchlaufen , um die URL zu extrahieren, zu der der Benutzer umgeleitet werden muss. Diese Beschriftung wird unter approval_url .

Das Format für die HATEOAS-Links kann bei direkter Verwendung zu fragilem Referenzcode führen. Daher werden alle bereitgestellten Links durchlaufen und in ein besseres Referenzobjekt eingefügt, um die Änderungen zukünftig zu sichern. Wenn dann die approval_url URL in diesem Objekt gefunden wird, leiten wir den Benutzer um.

Zu diesem Zeitpunkt wird der Benutzer zu PayPal weitergeleitet, um die Zahlung zu bestätigen. Sobald dies der return_url , werden sie zu dem in der Funktion createPayment(...) angegebenen createPayment(...) .

Wir müssen jetzt einen Weg angeben, um diese Rückgabe abzuwickeln, um die Zahlung abzuschließen.

app.get('/process', function(req, res){
    var paymentId = req.query.paymentId;
    var payerId = { 'payer_id': req.query.PayerID };

    paypal.payment.execute(paymentId, payerId, function(error, payment){
        if(error){
            console.error(error);
        } else {
            if (payment.state == 'approved'){ 
                res.send('payment completed successfully');
            } else {
                res.send('payment not successful');
            }
        }
    });
});

Wenn der Benutzer an Ihre App zurückgegeben wird, werden drei paymentId PayerID , die paymentId , PayerID und das token . Wir müssen uns nur mit den ersten beiden beschäftigen.

Wir extrahieren die Parameter und platzieren die PayerID in einem einfachen Objekt für den Zahlungsausführungsschritt. Als Nächstes erfolgt ein Aufruf an payment.execute(...) , wobei diese beiden Parameter übergeben werden, um die Zahlung abzuschließen.

Sobald dieser Antrag gestellt wird, sehen wir , wenn die abgeschlossene Zahlung erfolgreich durch Prüfen , ob payment.state gesetzt wird approved . In diesem Fall können wir speichern, was wir von dem zurückgegebenen Zahlungsobjekt benötigen.

Der letzte Schritt besteht darin, unseren Server zu initialisieren und auf den Verkehr zu achten, der auf die von uns angegebenen Routen kommt.

//create server
http.createServer(app).listen(3000, function () {
   console.log('Server started: Listening on port 3000');
});

Sobald der Server initialisiert ist, können Sie mit http://localhost:3000/create den Zahlungsvorgang starten.