PayPal
Abonnements anlegen / wiederkehrende Zahlungen

Parameter

Bemerkungen

Schritt 2: Erstellen eines Abonnements für einen Benutzer mithilfe einer Abrechnungsvereinbarung (Knotenbeispiel)

Der zweite Schritt zum Erstellen eines Abonnements für einen Benutzer ist das Erstellen und Ausführen einer Abrechnungsvereinbarung auf Grundlage eines vorhandenen aktivierten Abrechnungsplans. In diesem Beispiel wird davon ausgegangen, dass Sie im vorherigen Beispiel bereits einen Fakturierungsplan durchlaufen und aktiviert haben und über eine ID für diesen Fakturierungsplan verfügen, auf die im Beispiel verwiesen werden soll.

Wenn Sie eine Abrechnungsvereinbarung einrichten, um ein Abonnement für einen Benutzer zu erstellen, führen Sie drei Schritte aus, die an die Verarbeitung einer PayPal-Zahlung erinnern können:

1. Sie legen eine Fakturierungsvereinbarung an, die über die ID einen zugrunde liegenden Fakturierungsplan referenziert.
2. Nach dem Erstellen leiten Sie den Benutzer zu PayPal (bei Zahlung per PayPal), um das Abonnement zu bestätigen. Nach der Bestätigung leitet PayPal den Benutzer mithilfe der im zugrunde liegenden Abrechnungsplan angegebenen Weiterleitung auf Ihre Website zurück.
3. Anschließend führen Sie die Abrechnungsvereinbarung mit einem Token aus, das über die PayPal-Weiterleitung zurückgegeben wird.

In diesem Beispiel wird ein Express-basierter HTTP-Server eingerichtet, um den Rechnungslegungsprozess darzustellen.

Um das Beispiel zu starten, müssen wir zuerst unsere Konfiguration einrichten. Wir fügen vier Anforderungen hinzu, das PayPal-SDK, den body-parser für die Verarbeitung von JSON-codierten Körpern, http für unsere einfache Serverintegration und express für das Express-Framework. Wir definieren dann unsere Client-ID und das Geheimnis der Erstellung einer Anwendung, konfigurieren das SDK für die Sandbox und konfigurieren dann bodyParser für die Verarbeitung von JSON-Körpern.

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

Der erste Schritt in der Abrechnungsvereinbarung besteht darin, eine Route für die Erstellung einer Abrechnungsvereinbarung zu erstellen und den Benutzer zur Bestätigung dieses Abonnements an PayPal weiterzuleiten. Wir gehen davon aus, dass eine Abrechnungsplan-ID als Parameter für die Abfragezeichenfolge übergeben wird, beispielsweise durch Laden der folgenden URL mit einer Plan-ID aus dem vorherigen Beispiel:

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

Wir müssen diese Informationen nun verwenden, um die Abrechnungsvereinbarung zu erstellen.

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

Wir extrahieren zunächst die Fakturierungsplan-ID aus der Abfragezeichenfolge und erstellen das Datum, an dem der Plan beginnen soll.

Die nächste Objektdefinition, billingAgreementAttributes , besteht aus Informationen für das Abonnement. Es enthält lesbare Informationen zum Plan, einen Verweis auf die Fakturierungsplan-ID, die Zahlungsmethode und die Versanddetails (falls für das Abonnement erforderlich).

Als Nächstes wird ein Aufruf von billingAgreement.create(...) , der das soeben erstellte billingAgreementAttributes Objekt billingAgreementAttributes . Wenn alles erfolgreich ist, sollten wir einen Rechnungsvereinbarungsgegenstand mit Details zu unserem neu erstellten Abonnement an uns zurücksenden lassen. Dieses Objekt enthält auch eine Reihe von HATEOAS-Links, die uns die nächsten Schritte ermöglichen, die mit dieser neu erstellten Vereinbarung unternommen werden können. Die, die uns wichtig ist, wird als approval_url .

Wir durchlaufen alle bereitgestellten Links, um sie in einem leicht referenzierten Objekt abzulegen. Wenn approval_url einer dieser Links ist, leiten wir den Benutzer zu diesem Link weiter, der PayPal ist.

An diesem Punkt bestätigt der Benutzer das Abonnement bei PayPal und wird zu der im zugrunde liegenden Abrechnungsplan angegebenen URL zurückgeleitet. Neben dieser URL wird auch ein Token an die Abfragezeichenfolge übergeben. Dieses Token verwenden wir zum Ausführen (oder Starten) des Abonnements.

Lassen Sie uns diese Funktionalität auf folgende Weise einrichten.

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

Wir extrahieren das Token aus der billingAgreement.execute , rufen dann billingAgreement.execute und übergeben dieses Token. Wenn alles erfolgreich ist, haben wir jetzt ein gültiges Abonnement für den Benutzer. Das Rückgabeobjekt enthält Informationen zur aktiven Fakturierungsvereinbarung.

Schließlich haben wir unseren HTTP-Server so eingerichtet, dass er den Verkehr auf unseren Routen überwacht.

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

Schritt 1: Erstellen eines Abonnementmodells mithilfe eines Fakturierungsplans (Knotenbeispiel)

Wenn Sie ein Abonnement für einen Benutzer erstellen, müssen Sie zunächst einen Abrechnungsplan erstellen und aktivieren, den ein Benutzer dann mit einer Abrechnungsvereinbarung abonniert. Der vollständige Vorgang zum Erstellen eines Abonnements wird in den Anmerkungen zu diesem Thema beschrieben.

In diesem Beispiel verwenden wir das PayPal-Node-SDK . Sie können es von NPM mit dem folgenden Befehl erhalten:

npm install paypal-rest-sdk

In unserer .js-Datei haben wir zunächst unsere SDK-Konfiguration eingerichtet. Dazu gehört das Hinzufügen einer Anforderung für das SDK, das Definieren unserer Client-ID und des Geheims für das Erstellen unserer Anwendung sowie das Konfigurieren des SDK für die Sandbox-Umgebung.

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

Als Nächstes müssen wir zwei JSON-Objekte einrichten. Das billingPlanAttribs Objekt enthält die Informationen und Zahlungsaufschlüsselung für den Abrechnungsplan, die wir Benutzer abonnieren können, und das billingPlanUpdateAttributes Objekt enthält Werte für das Setzen des Abrechnungsplans auf einen aktiven Status, sodass es verwendet werden kann.

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"
    }
}];

Im Objekt billingPlanAttribs gibt es einige relevante Informationen:

• Name / Beschreibung / Typ : Grundlegende visuelle Informationen zur Beschreibung des Plans und der Art des Plans.
• payment_definitions : Informationen darüber, wie der Plan funktionieren soll und in Rechnung gestellt wird. Weitere Details zu den Feldern hier .
• merchant_preferences : Zusätzliche Gebührenstrukturen, Weiterleitungs-URLs und Einstellungen für den Abonnementplan. Weitere Details zu den Feldern hier .

Mit diesen Objekten können wir jetzt den Abrechnungsplan erstellen und aktivieren.

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

Wir rufen billingPlan.create(...) und übergeben das soeben erstellte billingPlanAttribs Objekt. Wenn dies erfolgreich ist, enthält das Rückgabeobjekt Informationen zum Fakturierungsplan. In diesem Beispiel müssen Sie lediglich die Fakturierungsplan-ID verwenden, um den Plan für die Verwendung zu aktivieren.

Als Nächstes rufen wir billingPlan.update(...) und übergeben die Fakturierungsplan-ID und das bereits erstellte billingPlanUpdateAttributes Objekt. Wenn dies erfolgreich ist, ist unser Abrechnungsplan jetzt aktiv und einsatzbereit.

Um ein Abonnement für einen Benutzer (oder mehrere Benutzer) für diesen Plan zu erstellen, müssen wir auf die Rechnungsplan-ID ( billingPlan.id oben) billingPlan.id , diese also an einem Ort speichern, der leicht referenziert werden kann.

Im zweiten Abonnementschritt müssen wir basierend auf dem soeben erstellten Plan eine Abrechnungsvereinbarung erstellen und ausführen, um Abonnements für einen Benutzer zu verarbeiten.