PayPal
Création d'abonnements / paiements récurrents

Paramètres

Remarques

Étape 2: Création d'un abonnement pour un utilisateur à l'aide d'un accord de facturation (exemple de noeud)

La deuxième étape de la création d'un abonnement pour un utilisateur consiste à créer et à exécuter un accord de facturation, basé sur un plan de facturation activé existant. Cet exemple suppose que vous avez déjà parcouru et activé un plan de facturation dans l'exemple précédent et que vous avez un ID pour ce plan de facturation à référencer dans l'exemple.

Lorsque vous configurez un accord de facturation pour créer un abonnement pour un utilisateur, vous suivrez trois étapes, qui peuvent vous rappeler de traiter un paiement PayPal:

1. Vous créez un accord de facturation en référençant un plan de facturation sous-jacent via l'ID.
2. Une fois créé, vous redirigez l'utilisateur vers PayPal (si vous payez via PayPal) pour confirmer l'abonnement. Une fois confirmé, PayPal redirige l'utilisateur vers votre site en utilisant la redirection fournie dans le plan de facturation sous-jacent.
3. Vous exécutez ensuite l'accord de facturation en utilisant un jeton fourni via la redirection PayPal.

Cet exemple consiste à configurer un serveur HTTP Express pour présenter le processus de contrat de facturation.

Pour démarrer l'exemple, nous devons d'abord configurer notre configuration. Nous avons ajouté quatre exigences, le kit de développement PayPal, l’ body-parser de body-parser pour la gestion des corps encodés JSON, l’ http pour notre intégration de serveur simple et l’ express pour le framework Express. Nous définissons ensuite notre identifiant client et le secret de création d'une application, configurons le SDK pour le bac à sable, puis configurons bodyParser pour gérer les corps 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());

Notre première étape dans l'accord de facturation consiste à créer un itinéraire pour gérer la création d'un accord de facturation et à rediriger l'utilisateur vers PayPal pour confirmer cet abonnement. Nous supposons qu'un ID de plan de facturation est transmis en tant que paramètre de chaîne de requête, par exemple en chargeant l'URL suivante avec un ID de plan de l'exemple précédent:

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

Nous devons maintenant utiliser ces informations pour créer l'accord de facturation.

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

Nous commençons par extraire l'identifiant du plan de facturation de la chaîne de requête et créons la date à laquelle le plan doit démarrer.

La définition d'objet suivante, billingAgreementAttributes , consiste en informations pour l'abonnement. Il contient des informations lisibles sur le plan, une référence à l'ID du plan de facturation, le mode de paiement et les détails d'expédition (si nécessaire pour l'abonnement).

Ensuite, un appel à billingAgreement.create(...) est effectué en transmettant l'objet billingAgreementAttributes nous venons de créer. Si tout se passe bien, nous devrions nous faire parvenir un objet d'accord de facturation contenant des détails sur notre abonnement nouvellement créé. Cet objet contient également un certain nombre de liens HATEOAS nous fournissant les prochaines étapes à suivre pour cet accord nouvellement créé. Celui qui nous intéresse ici est appelé approval_url .

Nous parcourons tous les liens fournis pour les placer dans un objet facilement référencé. Si approval_url est l'un de ces liens, nous redirigeons l'utilisateur vers ce lien, qui est PayPal.

À ce stade, l'utilisateur confirme l'abonnement sur PayPal et est redirigé vers l'URL fournie dans le plan de facturation sous-jacent. Parallèlement à cette URL, PayPal transmettra également un jeton le long de la chaîne de requête. Ce jeton est ce que nous allons utiliser pour exécuter (ou démarrer) l'abonnement.

Configurez cette fonctionnalité dans l'itinéraire suivant.

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

Nous extrayons le jeton de la chaîne de requête, puis nous appelons billingAgreement.execute , en transmettant ce jeton. Si tout est réussi, nous avons maintenant un abonnement valide pour l'utilisateur. L'objet de retour contient des informations sur l'accord de facturation actif.

Enfin, nous avons configuré notre serveur HTTP pour écouter le trafic sur nos routes.

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

Étape 1: Création d'un modèle d'abonnement à l'aide d'un plan de facturation (exemple de noeud)

Lors de la création d'un abonnement pour un utilisateur, vous devez d'abord créer et activer un calendrier de facturation auquel un utilisateur est ensuite abonné à l'aide d'un accord de facturation. Le processus complet de création d'un abonnement est détaillé dans les remarques de ce sujet.

Dans cet exemple, nous allons utiliser le SDK PayPal Node . Vous pouvez l'obtenir à partir de NPM à l'aide de la commande suivante:

npm install paypal-rest-sdk

Dans notre fichier .js, nous avons d'abord configuré notre configuration SDK, qui inclut l'ajout d'une exigence pour le SDK, la définition de notre ID client et le secret de création de notre application , puis la configuration du SDK pour l'environnement 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
});

Ensuite, nous devons configurer deux objets JSON. L'objet billingPlanAttribs contient les informations et la répartition des paiements pour le billingPlanAttribs facturation auquel nous pouvons abonner les utilisateurs, et l'objet billingPlanUpdateAttributes contient des valeurs permettant de définir le billingPlanUpdateAttributes facturation à un état actif, ce qui lui permet d'être utilisé.

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

Dans l'objet billingPlanAttribs , il existe des éléments d'information pertinents:

• nom / description / type : informations visuelles de base pour décrire le plan et le type de plan.
• payment_definitions : informations sur le fonctionnement et la facturation du plan. Plus de détails sur les champs ici .
• merchant_preferences : structures de frais supplémentaires, URL de redirection et paramètres du plan d'abonnement. Plus de détails sur les champs ici .

Avec ces objets en place, nous pouvons maintenant créer et activer le plan de facturation.

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

Nous appelons billingPlan.create(...) , en passant l'objet billingPlanAttribs que nous venons de créer. Si cela réussit, l'objet de retour contiendra des informations sur le plan de facturation. À titre d'exemple, il suffit d'utiliser l'ID du plan de facturation pour activer le plan à utiliser.

Ensuite, nous appelons billingPlan.update(...) , en transmettant l'ID du plan de facturation et l'objet billingPlanUpdateAttributes nous avons créé précédemment. Si cela réussit, notre plan de facturation est maintenant actif et prêt à être utilisé.

Afin de créer un abonnement pour un utilisateur (ou plusieurs utilisateurs) sur ce plan, nous devons référencer l'identifiant du plan de facturation ( billingPlan.id ci-dessus), afin de le stocker dans un endroit facilement référencable.

Lors de la deuxième étape de la souscription, nous devons créer un accord de facturation basé sur le plan que nous venons de créer et l'exécuter pour commencer à traiter les abonnements d'un utilisateur.