PayPal
Tworzenie subskrypcji / płatności cyklicznych

Parametry

Uwagi

Krok 2: Tworzenie subskrypcji dla użytkownika korzystającego z umowy rozliczeniowej (przykładowy węzeł)

Drugim krokiem do utworzenia subskrypcji dla użytkownika jest utworzenie i wykonanie umowy rozliczeniowej w oparciu o istniejący aktywowany plan rozliczeniowy. W tym przykładzie założono, że już przeszedłeś i aktywowałeś plan rozliczeniowy w poprzednim przykładzie, i masz identyfikator tego planu rozliczeniowego, do którego można się odwoływać w przykładzie.

Podczas konfigurowania umowy rozliczeniowej w celu utworzenia subskrypcji dla użytkownika postępujesz zgodnie z 3 krokami, które mogą przypominać przetwarzanie płatności PayPal:

1. Tworzysz umowę rozliczeniową, odwołując się do podstawowego planu rozliczeniowego za pomocą identyfikatora.
2. Po utworzeniu przekierowujesz użytkownika do PayPal (jeśli płacisz przez PayPal), aby potwierdzić subskrypcję. Po potwierdzeniu PayPal przekierowuje użytkownika z powrotem do Twojej witryny przy użyciu przekierowania podanego w podstawowym planie rozliczeniowym.
3. Następnie wykonujesz umowę rozliczeniową za pomocą tokena przekazanego z powrotem za pośrednictwem przekierowania PayPal.

W tym przykładzie skonfigurowano serwer HTTP Express w celu prezentacji procesu umowy rozliczeniowej.

Aby rozpocząć przykład, najpierw musimy skonfigurować naszą konfigurację. Dodajemy cztery wymagania, zestaw PayPal SDK, body-parser do obsługi treści kodowanych w JSON, http dla naszej prostej integracji z serwerem i express dla frameworka Express. Następnie definiujemy identyfikator klienta i klucz tajny podczas tworzenia aplikacji, konfigurujemy zestaw SDK dla piaskownicy, a następnie konfigurujemy bodyParser do obsługi treści JSON.

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

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

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

app.use(bodyParser.json());

Naszym pierwszym krokiem w umowie rozliczeniowej jest utworzenie trasy do obsługi umowy rozliczeniowej i przekierowanie użytkownika do PayPal w celu potwierdzenia subskrypcji. Zakładamy, że identyfikator planu rozliczeniowego jest przekazywany jako parametr ciągu zapytania, na przykład poprzez załadowanie następującego adresu URL o identyfikatorze planu z poprzedniego przykładu:

http://localhost:3000/createagreement?plan=P-3N543779E9831025ECYGDNVQ

Teraz musimy wykorzystać te informacje, aby utworzyć umowę rozliczeniową.

app.get('/createagreement', function(req, res){
    var billingPlan = req.query.plan;
    
    var isoDate = new Date();
    isoDate.setSeconds(isoDate.getSeconds() + 4);
    isoDate.toISOString().slice(0, 19) + 'Z';

    var billingAgreementAttributes = {
        "name": "Standard Membership",
        "description": "Food of the World Club Standard Membership",
        "start_date": isoDate,
        "plan": {
            "id": billingPlan
        },
        "payer": {
            "payment_method": "paypal"
        },
        "shipping_address": {
            "line1": "W 34th St",
            "city": "New York",
            "state": "NY",
            "postal_code": "10001",
            "country_code": "US"
        }
    };

    // Use activated billing plan to create agreement
    paypal.billingAgreement.create(billingAgreementAttributes, function (error, billingAgreement){
        if (error) {
            console.error(error);
            throw error;
        } else {
            //capture HATEOAS links
            var links = {};
            billingAgreement.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');
            }
        }
    });
});

Zaczynamy od wyodrębnienia identyfikatora planu bilingowego z ciągu zapytania i tworzymy datę rozpoczęcia planu.

Następna definicja obiektu, billingAgreementAttributes , zawiera informacje dotyczące subskrypcji. Zawiera czytelne informacje o abonamencie, odniesienie do identyfikatora abonamentu, metody płatności i szczegółów wysyłki (w razie potrzeby subskrypcji).

Następnie następuje wywołanie billingAgreement.create(...) , przekazując właśnie utworzony obiekt billingAgreementAttributes . Jeśli wszystko się powiedzie, powinniśmy zwrócić obiekt umowy rozliczeniowej zawierający szczegóły dotyczące naszej nowo utworzonej subskrypcji. Ten obiekt zawiera również szereg łączy HATEOAS, które dostarczają nam kolejnych kroków, które można podjąć w sprawie tej nowo utworzonej umowy. Ten, na którym nam zależy, jest oznaczony jako approval_url .

Przechodzimy przez wszystkie dostarczone linki, aby umieścić je w łatwym do odwołania obiekcie. Jeśli approval_url jest jednym z tych łączy, przekierowujemy użytkownika do tego łącza, którym jest PayPal.

W tym momencie użytkownik potwierdza subskrypcję w systemie PayPal i zostaje przekierowany z powrotem na adres URL podany w podstawowym planie rozliczeniowym. Wraz z tym adresem URL PayPal przekaże również token wzdłuż ciągu zapytania. Tego tokena użyjemy do wykonania (lub uruchomienia) subskrypcji.

Ustawmy tę funkcjonalność na następującej trasie.

app.get('/processagreement', function(req, res){
    var token = req.query.token;
    
    paypal.billingAgreement.execute(token, {}, function (error, billingAgreement) {
        if (error) {
            console.error(error);
            throw error;
        } else {
            console.log(JSON.stringify(billingAgreement));
            res.send('Billing Agreement Created Successfully');
        }
    });
});

billingAgreement.execute token z ciągu zapytania, a następnie wywołujemy billingAgreement.execute , przekazując ten token. Jeśli wszystko się powiedzie, mamy teraz ważną subskrypcję dla użytkownika. Obiekt zwrotu zawiera informacje o aktywnej umowie rozliczeniowej.

Na koniec skonfigurowaliśmy nasz serwer HTTP, aby nasłuchiwał ruchu na naszych trasach.

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

Krok 1: Tworzenie modelu subskrypcji przy użyciu abonamentu (przykładowy węzeł)

Tworząc subskrypcję dla użytkownika, musisz najpierw utworzyć i aktywować abonament, który następnie użytkownik subskrybuje za pomocą umowy rozliczeniowej. Pełny proces tworzenia subskrypcji opisano szczegółowo w uwagach do tego tematu.

W tym przykładzie będziemy używać zestawu SDK do węzłów PayPal . Możesz go uzyskać z NPM za pomocą następującego polecenia:

npm install paypal-rest-sdk

W naszym pliku .js najpierw konfigurujemy konfigurację zestawu SDK, która obejmuje dodanie wymagania dla zestawu SDK, zdefiniowanie identyfikatora klienta i hasła podczas tworzenia naszej aplikacji , a następnie skonfigurowanie zestawu SDK dla środowiska piaskownicy.

var paypal = require('paypal-rest-sdk');

var clientId = 'YOUR CLIENT ID';
var secret = 'YOUR SECRET';

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

Następnie musimy skonfigurować dwa obiekty JSON. Obiekt billingPlanAttribs zawiera informacje i podział płatności dla planu bilingowego, do którego możemy subskrybować użytkowników, a obiekt billingPlanUpdateAttributes zawiera wartości służące do ustawienia planu bilingowego na stan aktywny, umożliwiając jego użycie.

var billingPlanAttribs = {
    "name": "Food of the World Club Membership: Standard",
    "description": "Monthly plan for getting the t-shirt of the month.",
    "type": "fixed",
    "payment_definitions": [{
        "name": "Standard Plan",
        "type": "REGULAR",
        "frequency_interval": "1",
        "frequency": "MONTH",
        "cycles": "11",
        "amount": {
            "currency": "USD",
            "value": "19.99"
        }
    }],
    "merchant_preferences": {
        "setup_fee": {
            "currency": "USD",
            "value": "1"
        },
        "cancel_url": "http://localhost:3000/cancel",
        "return_url": "http://localhost:3000/processagreement",
        "max_fail_attempts": "0",
        "auto_bill_amount": "YES",
        "initial_fail_amount_action": "CONTINUE"
    }
};

var billingPlanUpdateAttributes = [{
    "op": "replace",
    "path": "/",
    "value": {
        "state": "ACTIVE"
    }
}];

W obiekcie billingPlanAttribs znajduje się kilka istotnych informacji:

• nazwa / opis / typ : Podstawowe informacje wizualne opisujące plan i rodzaj planu.
• payment_definitions : Informacje o tym, jak plan powinien funkcjonować i być rozliczany. Więcej informacji na temat pól tutaj .
• merchant_preferences : dodatkowe struktury opłat, adresy URL przekierowań i ustawienia abonamentu. Więcej informacji na temat pól tutaj .

Po umieszczeniu tych obiektów możemy teraz utworzyć i aktywować plan rozliczeniowy.

paypal.billingPlan.create(billingPlanAttribs, function (error, billingPlan){
    if (error){
        console.log(error);
        throw error;
    } else {
        // Activate the plan by changing status to Active
        paypal.billingPlan.update(billingPlan.id, billingPlanUpdateAttributes, function(error, response){
            if (error) {
                console.log(error);
                throw error;
            } else {
                console.log(billingPlan.id);
            }
        });
    }
});

Nazywamy billingPlan.create(...) , przekazując właśnie utworzony obiekt billingPlanAttribs . Jeśli to się powiedzie, obiekt zwrotu będzie zawierał informacje o planie rozliczeniowym. Na przykład wystarczy użyć identyfikatora abonamentu, aby aktywować abonament.

Następnie wywołujemy billingPlan.update(...) , przekazując identyfikator planu bilingowego i obiekt billingPlanUpdateAttributes który wcześniej utworzyliśmy. Jeśli to się powiedzie, nasz plan rozliczeniowy jest teraz aktywny i gotowy do użycia.

Aby utworzyć subskrypcję dla użytkownika (lub wielu użytkowników) w tym abonamencie, musimy odwołać się do identyfikatora abonamentu ( billingPlan.id powyżej), więc przechowuj go w miejscu, do którego można łatwo się odwołać.

W drugim etapie subskrypcji musimy utworzyć umowę rozliczeniową na podstawie właśnie utworzonego planu i wykonać go, aby rozpocząć przetwarzanie subskrypcji dla użytkownika.