PayPal
Creazione di abbonamenti / pagamenti ricorrenti

Parametri

Osservazioni

Passaggio 2: creazione di una sottoscrizione per un utente che utilizza un contratto di fatturazione (esempio di nodo)

Il secondo passaggio per creare un abbonamento per un utente è creare ed eseguire un contratto di fatturazione, in base a un piano di fatturazione attivato esistente. Questo esempio presuppone che tu abbia già eseguito e attivato un piano di fatturazione nell'esempio precedente e che un ID per tale piano di fatturazione faccia riferimento nell'esempio.

Quando imposti un contratto di fatturazione per creare un abbonamento per un utente, seguirai 3 passaggi, che potrebbero ricordare l'elaborazione di un pagamento PayPal:

1. Si crea un contratto di fatturazione, facendo riferimento a un piano di fatturazione sottostante tramite l'ID.
2. Una volta creato, reindirizza l'utente a PayPal (se paga tramite PayPal) per confermare l'abbonamento. Una volta confermato, PayPal reindirizza l'utente al tuo sito utilizzando il reindirizzamento fornito nel piano di fatturazione sottostante.
3. Esegui quindi il contratto di fatturazione utilizzando un token restituito tramite il reindirizzamento PayPal.

Questo esempio sta configurando un server HTTP basato su Express per mostrare il processo del contratto di fatturazione.

Per iniziare l'esempio, dobbiamo prima impostare la nostra configurazione. Aggiungiamo quattro requisiti, l'SDK PayPal, body-parser per la gestione dei corpi codificati JSON, http per la nostra semplice integrazione con i server e express per il framework Express. Quindi definiamo il nostro ID client e segreto dalla creazione di un'applicazione, configuriamo l'SDK per la sandbox, quindi configuriamo bodyParser per la gestione dei corpi 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());

Il nostro primo passo nel contratto di fatturazione è creare un percorso per gestire la creazione di un contratto di fatturazione e reindirizzare l'utente su PayPal per confermare tale iscrizione. Supponiamo che un ID del piano di fatturazione venga passato come parametro della stringa di query, ad esempio caricando il seguente URL con un ID del piano dell'esempio precedente:

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

Ora dobbiamo usare queste informazioni per creare il contratto di fatturazione.

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

Iniziamo estraendo l'ID del piano di fatturazione dalla stringa di query e creando la data in cui il piano dovrebbe iniziare.

La successiva definizione dell'oggetto, billingAgreementAttributes , consiste in informazioni per la sottoscrizione. Contiene informazioni leggibili sul piano, un riferimento all'ID del piano di fatturazione, il metodo di pagamento e i dettagli di spedizione (se necessario per l'abbonamento).

Successivamente, viene effettuata una chiamata a billingAgreement.create(...) , passando nell'oggetto billingAgreementAttributes appena creato. Se tutto è andato a buon fine, dovremmo ricevere da noi un oggetto di contratto di fatturazione contenente i dettagli sul nostro abbonamento appena creato. Tale oggetto contiene anche una serie di collegamenti HATEOAS che ci forniscono i prossimi passi che possono essere intrapresi su questo accordo appena creato. Quello che ci interessa qui è etichettato come approval_url .

Passiamo in rassegna tutti i collegamenti forniti per metterli in un oggetto facilmente referenziato. Se approval_url è uno di quei link, reindirizziamo l'utente a quel link, che è PayPal.

A questo punto l'utente conferma l'iscrizione su PayPal e viene reindirizzato all'URL fornito nel piano di fatturazione sottostante. Insieme a tale URL, PayPal passerà anche un token lungo la stringa di query. Quel token è ciò che useremo per eseguire (o avviare) l'abbonamento.

Impostiamo questa funzionalità nel seguente percorso.

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

Estraiamo il token dalla stringa di query, quindi effettuiamo una chiamata a billingAgreement.execute , passando per quel token. Se tutto ha successo, ora abbiamo un abbonamento valido per l'utente. L'oggetto di reso contiene informazioni sul contratto di fatturazione attivo.

Infine, impostiamo il nostro server HTTP per ascoltare il traffico verso i nostri percorsi.

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

Passaggio 1: creazione di un modello di abbonamento utilizzando un piano di fatturazione (esempio di nodo)

Quando si crea un abbonamento per un utente, è prima necessario creare e attivare un piano di fatturazione a cui un utente è quindi iscritto utilizzando un contratto di fatturazione. Il processo completo per la creazione di un abbonamento è dettagliato nelle osservazioni di questo argomento.

All'interno di questo esempio, utilizzeremo l' SDK del nodo PayPal . Puoi ottenerlo da NPM usando il seguente comando:

npm install paypal-rest-sdk

All'interno del nostro file .js, per prima cosa configuriamo la nostra configurazione dell'SDK, che include l'aggiunta di un requisito per l'SDK, la definizione dell'ID client e del segreto dalla creazione della nostra applicazione e quindi la configurazione dell'SDK per l'ambiente sandbox.

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

Quindi, dobbiamo impostare due oggetti JSON. L'oggetto billingPlanAttribs contiene le informazioni e la ripartizione dei pagamenti per il piano di fatturazione a cui possiamo iscrivere gli utenti e l'oggetto di billingPlanUpdateAttributes contiene i valori per impostare il piano di fatturazione su uno stato attivo, consentendone l'utilizzo.

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

billingPlanAttribs , ci sono alcune informazioni rilevanti:

• nome / descrizione / tipo : informazioni visive di base per descrivere il piano e il tipo di piano.
• payment_definitions : informazioni su come il piano dovrebbe funzionare e essere fatturato. Maggiori dettagli sui campi qui .
• merchant_preferences : strutture tariffarie aggiuntive, URL di reindirizzamento e impostazioni per il piano di abbonamento. Maggiori dettagli sui campi qui .

Con questi oggetti, ora possiamo creare e attivare il piano di fatturazione.

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

Chiamiamo billingPlan.create(...) , passando l'oggetto billingPlanAttribs che abbiamo appena creato. Se ciò ha esito positivo, l'oggetto di ritorno conterrà informazioni sul piano di fatturazione. Per fare un esempio, è sufficiente utilizzare l'ID del piano di fatturazione per attivare il piano per l'uso.

Successivamente, chiamiamo billingPlan.update(...) , passando l'ID del piano di fatturazione e l'oggetto di billingPlanUpdateAttributes che abbiamo creato in precedenza. Se ciò è successo, il nostro piano di fatturazione è ora attivo e pronto per l'uso.

Per creare un abbonamento per un utente (o più utenti) su questo piano, dovremo fare riferimento billingPlan.id piano di fatturazione ( billingPlan.id sopra), quindi memorizzarlo in un luogo a cui è possibile fare riferimento facilmente.

Nella seconda fase della sottoscrizione, dobbiamo creare un contratto di fatturazione basato sul piano appena creato ed eseguirlo per iniziare l'elaborazione delle sottoscrizioni per un utente.