PayPal
Dokonanie płatności PayPal

Parametry

Uwagi

Przykład serwera Node Express Server

W tym przykładzie skonfigurujemy integrację z serwerem Express, aby wyświetlać sposób przetwarzania płatności za pomocą PayPal przy użyciu zestawu SDK do węzłów PayPal. Będziemy używać statycznej struktury JSON do szczegółów płatności ze względu na zwięzłość.

Istnieją trzy ogólne kroki, które powinniśmy wykonać, budując funkcje do obsługi płatności PayPal:

1. Tworzymy obiekt JSON zawierający płatność, którą zamierzamy przetworzyć za pośrednictwem PayPal. Następnie wysyłamy to do PayPal, aby uzyskać link do przekierowania użytkownika w celu potwierdzenia płatności.
2. Następnie przekierowujemy użytkownika do PayPal, aby potwierdzić płatność. Po potwierdzeniu PayPal przekierowuje użytkownika z powrotem do naszej aplikacji.
3. Po powrocie do aplikacji dokonujemy płatności w imieniu użytkownika.

Rozbijając to na prostą aplikację Node, zaczynamy od uzyskania zestawu SDK PayPal Node od NPM:

npm install paypal-rest-sdk

Następnie konfigurujemy konfigurację aplikacji i pakiety.

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
});

Wymagamy czterech wymagań dla tej aplikacji:

1. Pakiet HTTP dla naszego serwera.
2. Pakiet SDK do węzła PayPal.
3. Pakiet bodyParser do pracy z obiektami zakodowanymi w JSON.
4. Struktura Express dla naszego serwera.

Następne kilka linii konfiguruje zmienne dla identyfikatora klienta i hasła, które zostały uzyskane podczas tworzenia aplikacji . Następnie konfigurujemy bodyParser aby zezwalał na ciała zakodowane w JSON, następnie konfigurujemy naszą aplikację przy użyciu szczegółów aplikacji i określamy środowisko, w którym pracujemy (na żywo do produkcji lub piaskownicy do testowania).

Teraz utwórzmy trasę tworzenia żądania płatności za pomocą 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');
            }
        }
    });
});

Pierwszą rzeczą, którą robimy, jest skonfigurowanie obiektu JSON żądania płatności, który zawiera informacje, które musimy podać PayPal, aby utworzyć płatność. Ustawiamy intent sale , określamy adresy URL przekierowań (na które PayPal powinien przekierować użytkownika po potwierdzeniu / anulowaniu płatności), dodamy payment_method płatności paypal aby zasygnalizować, że dokonamy płatności PayPal, a następnie określ informacje dotyczące transakcji płatnik do potwierdzenia.

Następnie wywołujemy payment.create(...) , przekazując nasz obiekt payReq . Spowoduje to wysłanie żądania utworzenia płatności do PayPal. Po powrocie i powodzeniu możemy zapętlać dostarczone linki HATEOAS w obiekcie zwrotnym, aby wyodrębnić adres URL, do którego musimy przekierować użytkownika, który jest oznaczony jako approval_url .

Format łączy HATEOAS może powodować kruchy kod referencyjny, jeśli zostanie użyty bezpośrednio, więc zapętlamy wszystkie dostarczone linki i umieszczamy je w lepszym obiekcie referencyjnym, aby w przyszłości był odporny na zmiany. Jeśli approval_url jest wtedy znaleźć w tym obiekcie, możemy przekierować użytkownika.

W tym momencie użytkownik zostaje przekierowany do PayPal w celu potwierdzenia płatności. Gdy to zrobią, zostaną przekierowani z powrotem na return_url określony w funkcji createPayment(...) .

Teraz musimy podać trasę obsługi zwrotu, aby zrealizować płatność.

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');
            }
        }
    });
});

Gdy użytkownik powróci do Twojej aplikacji, zostaną wysłane trzy parametry ciągu zapytania, które zostaną wysłane, paymentId , PayerID i token . Musimy poradzić sobie tylko z pierwszymi dwoma.

Wyodrębniamy parametry i umieszczamy PayerID w prostym obiekcie na potrzeby etapu wykonania płatności. Następnie wywoływane jest wezwanie do payment.execute(...) , przekazując te dwa parametry, w celu dokończenia płatności.

Po wysłaniu tego żądania sprawdzamy, czy płatność została pomyślnie zakończona, sprawdzając, czy parametr payment.state jest ustawiony na approved . Jeśli tak, możemy przechowywać to, czego potrzebujemy ze zwróconego obiektu płatności.

Naszym ostatnim krokiem jest zainicjowanie naszego serwera i nasłuchiwanie ruchu przychodzącego na określone trasy.

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

Po zainicjowaniu serwera przejście do http://localhost:3000/create inicjuje proces płatności.