PayPal
Creación de suscripciones / pagos periódicos

Parámetros

Observaciones

Paso 2: creación de una suscripción para un usuario mediante un acuerdo de facturación (ejemplo de nodo)

El segundo paso para crear una suscripción para un usuario es crear y ejecutar un acuerdo de facturación, basado en un plan de facturación activado existente. Este ejemplo asume que ya ha pasado y activado un plan de facturación en el ejemplo anterior, y tiene una identificación para que el plan de facturación haga referencia en el ejemplo.

Cuando esté configurando un acuerdo de facturación para crear una suscripción para un usuario, seguirá tres pasos, que pueden ser una reminiscencia de procesar un pago de PayPal:

1. Usted crea un acuerdo de facturación, haciendo referencia a un plan de facturación subyacente a través de la identificación.
2. Una vez creado, redirige al usuario a PayPal (si paga mediante PayPal) para confirmar la suscripción. Una vez confirmado, PayPal redirige al usuario a su sitio utilizando la redirección provista en el plan de facturación subyacente.
3. A continuación, ejecuta el acuerdo de facturación utilizando un token proporcionado a través de la redirección de PayPal.

Este ejemplo está configurando un servidor HTTP basado en Express para mostrar el proceso de acuerdo de facturación.

Para comenzar el ejemplo, primero necesitamos configurar nuestra configuración. Agregamos cuatro requisitos, el SDK de PayPal, body-parser de body-parser para manejar cuerpos codificados JSON, http para nuestra integración de servidor simple y express para el marco Express. Luego definimos nuestro ID de cliente y el secreto para crear una aplicación, configuramos el SDK para el recinto de seguridad y luego configuramos bodyParser para manejar cuerpos 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());

Nuestro primer paso en el acuerdo de facturación es crear una ruta para manejar la creación de un acuerdo de facturación, y redirigir al usuario a PayPal para confirmar esa suscripción. Suponemos que se pasa un ID de plan de facturación como un parámetro de cadena de consulta, como al cargar la siguiente URL con un ID de plan del ejemplo anterior:

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

Ahora necesitamos usar esa información para crear el acuerdo de facturación.

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

Comenzamos extrayendo el ID del plan de facturación de la cadena de consulta y creamos la fecha en que debe comenzar el plan.

La siguiente definición de objeto, billingAgreementAttributes , consiste en información para la suscripción. Contiene información legible sobre el plan, una referencia a la identificación del plan de facturación, el método de pago y los detalles de envío (si es necesario para la suscripción).

A continuación, se realiza una llamada a billingAgreement.create(...) , pasando el objeto billingAgreementAttributes que acabamos de crear. Si todo tiene éxito, deberíamos tener un objeto de acuerdo de facturación que nos sea devuelto con detalles sobre nuestra suscripción recién creada. Ese objeto también contiene una serie de enlaces de HATEOAS que nos proporcionan los próximos pasos que se pueden tomar en este acuerdo recién creado. El que nos importa aquí está etiquetado como approval_url .

Recorremos todos los enlaces provistos para colocarlos en un objeto de fácil referencia. Si approval_url es uno de esos enlaces, redirigimos al usuario a ese enlace, que es PayPal.

En este punto, el usuario confirma la suscripción en PayPal y se redirige de nuevo a la URL proporcionada en el plan de facturación subyacente. Junto con esa URL, PayPal también pasará un token a lo largo de la cadena de consulta. Ese token es lo que usaremos para ejecutar (o iniciar) la suscripción.

Vamos a configurar esa funcionalidad en la siguiente ruta.

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

Extraemos el token de la cadena de consulta, luego hacemos una llamada a billingAgreement.execute , pasando ese token. Si todo tiene éxito, ahora tenemos una suscripción válida para el usuario. El objeto de devolución contiene información sobre el acuerdo de facturación activo.

Por último, configuramos nuestro servidor HTTP para escuchar el tráfico a nuestras rutas.

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

Paso 1: crear un modelo de suscripción utilizando un plan de facturación (ejemplo de nodo)

Al crear una suscripción para un usuario, primero debe crear y activar un plan de facturación al que se suscriba un usuario mediante un acuerdo de facturación. El proceso completo para crear una suscripción se detalla en las observaciones de este tema.

En este ejemplo, vamos a utilizar el SDK de nodo de PayPal . Puedes obtenerlo de NPM usando el siguiente comando:

npm install paypal-rest-sdk

Dentro de nuestro archivo .js, primero configuramos nuestra configuración de SDK, que incluye agregar un requisito para el SDK, definir nuestro ID de cliente y el secreto para crear nuestra aplicación , y luego configurar el SDK para el entorno de 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
});

A continuación, necesitamos configurar dos objetos JSON. El objeto billingPlanAttribs contiene la información y el desglose de pagos del plan de facturación al que podemos suscribir a los usuarios, y el objeto billingPlanUpdateAttributes contiene valores para configurar el plan de facturación en un estado activo, lo que permite su uso.

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

Dentro del objeto billingPlanAttribs , hay algunos datos relevantes:

• nombre / descripción / tipo : información visual básica para describir el plan y el tipo de plan.
• Payment_definitions : Información sobre cómo debería funcionar y facturarse el plan. Más detalles sobre los campos aquí .
• merchant_preferences : estructuras de tarifas adicionales, URL de redireccionamiento y configuraciones para el plan de suscripción. Más detalles sobre los campos aquí .

Con esos objetos en su lugar, ahora podemos crear y activar el plan de facturación.

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

Llamamos a billingPlan.create(...) , pasando el objeto billingPlanAttribs que acabamos de crear. Si eso tiene éxito, el objeto devuelto contendrá información sobre el plan de facturación. Por el bien del ejemplo, solo necesitamos usar la ID del plan de facturación para activar el plan para su uso.

A continuación, llamamos a billingPlan.update(...) y billingPlanUpdateAttributes la ID del plan de facturación y el objeto billingPlanUpdateAttributes que creamos anteriormente. Si eso tiene éxito, nuestro plan de facturación ahora está activo y listo para usar.

Para crear una suscripción para un usuario (o varios usuarios) en este plan, necesitaremos hacer referencia al ID del plan de facturación ( billingPlan.id anterior), así que guárdelo en un lugar al que se pueda hacer referencia fácilmente.

En el segundo paso de suscripción, debemos crear un acuerdo de facturación basado en el plan que acabamos de crear y ejecutarlo para comenzar a procesar las suscripciones para un usuario.