PayPal
Skapa prenumerationer / återkommande betalningar

parametrar

Anmärkningar

Steg 2: Skapa ett prenumeration för en användare med ett faktureringsavtal (nodprov)

Det andra steget för att skapa ett abonnemang för en användare är att skapa och genomföra ett faktureringsavtal baserat på en befintlig aktiverad faktureringsplan. Detta exempel antar att du redan har gått igenom och aktiverat en faktureringsplan i det föregående exemplet och har ett ID för den faktureringsplanen som referens i exemplet.

När du skapar ett faktureringsavtal för att skapa en prenumeration för en användare följer du tre steg, som kan påminna om att hantera en PayPal-betalning:

1. Du skapar ett faktureringsavtal med en underliggande faktureringsplan via ID.
2. När du skapat omdirigerar du användaren till PayPal (om du betalar via PayPal) för att bekräfta prenumerationen. När det har bekräftats omdirigerar PayPal användaren tillbaka till din webbplats med den omdirigering som finns i den underliggande faktureringsplanen.
3. Du kör sedan faktureringsavtalet med ett token som tillhandahålls via PayPal-omdirigering.

Detta exempel är att ställa in en Express-baserad HTTP-server för att visa upp faktureringsavtalsprocessen.

För att starta exemplet måste vi först ställa in vår konfiguration. Vi lägger till fyra krav, PayPal SDK, body-parser för hantering av JSON-kodade organ, http för vår enkla serverintegration och express för Express-ramverket. Vi definierar sedan vårt klient-ID och hemlighet från att skapa ett program, konfigurera SDK för sandlådan och konfigurera sedan bodyParser för hantering av JSON-organ.

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

Vårt första steg i faktureringsavtalet är att skapa en väg att hantera skapandet av ett faktureringsavtal och omdirigera användaren till PayPal för att bekräfta det prenumerationen. Vi antar att ett faktureringsplan-ID skickas som en frågesträngparameter, till exempel genom att ladda följande URL med ett plan-ID från föregående exempel:

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

Vi måste nu använda den informationen för att skapa faktureringsavtalet.

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

Vi börjar med att extrahera faktureringsplan-ID från frågesträngen och skapar datumet när planen börjar.

Nästa billingAgreementAttributes , billingAgreementAttributes , består av information för prenumerationen. Den innehåller läsbar information om planen, en hänvisning till faktureringsplan-ID, betalningsmetod och leveransinformation (om det behövs för prenumerationen).

Därefter ringer billingAgreement.create(...) till billingAgreement.create(...) och skickar in det billingAgreementAttributes objektet vi just skapade. Om allt är framgångsrikt bör vi få ett faktureringsavtalobjekt tillbaka till oss som innehåller information om vårt nyskapade prenumeration. Det objektet innehåller också ett antal HATEOAS-länkar som ger oss nästa steg som kan vidtas i detta nyskapade avtal. Den vi bryr oss om här är märkt som approval_url .

Vi går igenom alla medföljande länkar för att placera dem i ett enkelt referensobjekt. Om approval_url är en av dessa länkar, omdirigerar vi användaren till den länken, som är PayPal.

Vid denna punkt bekräftar användaren prenumerationen på PayPal och omdirigeras tillbaka till URL: en som finns i den underliggande faktureringsplanen. Tillsammans med den URL kommer PayPal också att skicka ett token längs frågesträngen. Det symbolet är det vi ska använda för att köra (eller starta) prenumerationen.

Låt oss ställa in den funktionen i följande rutt.

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

Vi extraherar tokenet från frågesträngen och ringer sedan till billingAgreement.execute och passerar längs det token. Om allt lyckas har vi nu ett giltigt prenumeration för användaren. Returobjektet innehåller information om det aktiva faktureringsavtalet.

Slutligen skapade vi vår HTTP-server för att lyssna på trafik till våra rutter.

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

Steg 1: Skapa en prenumerationsmodell med en faktureringsplan (nodprov)

När du skapar ett prenumeration för en användare måste du först skapa och aktivera en faktureringsplan som en användare sedan prenumererar på med hjälp av ett faktureringsavtal. Hela processen för att skapa ett prenumeration beskrivs i kommentarerna till detta ämne.

I det här exemplet kommer vi att använda PayPal Node SDK . Du kan få den från NPM med följande kommando:

npm install paypal-rest-sdk

I vår .js-fil konfigurerar vi först vår SDK-konfiguration, som inkluderar att lägga till ett krav för SDK, definiera vårt klient-ID och hemlighet från att skapa vår applikation och sedan konfigurera SDK för sandlådans miljö.

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

Därefter måste vi ställa in två JSON-objekt. billingPlanAttribs objektet innehåller information och betalningsfördelning för faktureringsplanen som vi kan prenumerera användare på, och billingPlanUpdateAttributes objektet innehåller värden för att sätta faktureringsplanen till ett aktivt tillstånd, så att det kan användas.

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

Inom billingPlanAttribs objektet finns det några relevanta information:

• namn / beskrivning / typ : Grundläggande visuell information för att beskriva planen och typen av plan.
• Payment_definitions : Information om hur planen ska fungera och faktureras. Mer information om fält här .
• merchant_preferences : Ytterligare avgiftsstrukturer, omdirigeringsadresser och inställningar för prenumerationsplanen. Mer information om fält här .

Med dessa objekt på plats kan vi nu skapa och aktivera faktureringsplanen.

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

Vi kallar billingPlan.create(...) och skickar in det billingPlanAttribs objektet som vi just skapade. Om det lyckas kommer returobjektet att innehålla information om faktureringsplanen. För exemplet behöver vi bara använda faktureringsplan-ID för att aktivera planen för användning.

Därefter kallar vi billingPlan.update(...) och skickar in faktureringsplan-ID och billingPlanUpdateAttributes objektet som vi skapade tidigare. Om det lyckas är vår faktureringsplan nu aktiv och redo att användas.

För att skapa en prenumeration för en användare (eller flera användare) på den här planen måste vi hänvisa till faktureringsplan-id ( billingPlan.id ovan), så lagra det på en plats som enkelt kan refereras till.

I det andra prenumerationssteget måste vi skapa ett faktureringsavtal baserat på planen vi just skapade och utföra det för att börja behandla prenumerationer för en användare.