Crear Suscripciones Pagos Recurrentes

Parámetros #

Estos ejemplos pasan por el proceso de creación de un sistema de suscripción/pago recurrente utilizando PayPal.

El proceso para crear una suscripción es:

1. Cree un plan de facturación. Este es un modelo reutilizable que describe los detalles de la suscripción.
2. Activa el plan de facturación.
3. Cuando desee crear una suscripción para un usuario, cree un acuerdo de facturación utilizando el ID del plan de facturación al que debe estar suscrito.
4. Una vez creada, redireccionas al usuario a PayPal para que confirme la suscripción. Una vez confirmado, se redirige al usuario al sitio web del comerciante.
5. Por último, ejecuta el acuerdo de facturación para comenzar la suscripción.

Paso 2: crear 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 pasó y activó un plan de facturación en el ejemplo anterior, y tiene una identificación para ese plan de facturación para hacer referencia en el ejemplo.

Cuando configure un acuerdo de facturación para crear una suscripción para un usuario, deberá seguir 3 pasos, que pueden recordar el procesamiento de un pago de PayPal:

1. Crea un acuerdo de facturación, haciendo referencia a un plan de facturación subyacente a través de la ID.
2. Una vez creado, redirige al usuario a PayPal (si paga a través de PayPal) para confirmar la suscripción. Una vez confirmado, PayPal redirige al usuario a su sitio utilizando la redirección proporcionada en el plan de facturación subyacente.
3. Luego 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 del acuerdo de facturación.

Para comenzar con el ejemplo, primero debemos establecer nuestra configuración. Agregamos cuatro requisitos, el SDK de PayPal, body-parser para manejar cuerpos codificados en JSON, http para nuestra integración de servidor simple y express para el marco Express. Luego definimos nuestro ID de cliente y el secreto de la creación de una aplicación, configuramos el SDK para el espacio aislado 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, por ejemplo, cargando 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 la que debería comenzar el plan.

La siguiente definición de objeto, billingAgreementAttributes, consta de información para la suscripción. Contiene información legible sobre el plan, una referencia al ID 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 es exitoso, deberíamos recibir un objeto de acuerdo de facturación que contenga detalles sobre nuestra suscripción recién creada. Ese objeto también contiene una serie de enlaces HATEOAS que nos brindan los próximos pasos que se pueden tomar en este acuerdo recién creado. El que nos interesa aquí está etiquetado como approval_url.

Recorremos todos los enlaces proporcionados para colocarlos en un objeto fácilmente referenciable. 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 le redirige 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 vamos a usar para ejecutar (o iniciar) la suscripción.

Configuremos 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 es exitoso, 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 de nuestras rutas.

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

Paso 1: creación de un modelo de suscripción mediante un plan de facturación (muestra de nodo) #

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

Dentro de este ejemplo, vamos a utilizar el SDK de nodo de PayPal. Puede 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 de [crear nuestra aplicación][2], y luego configurar el SDK para el entorno de espacio aislado.

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, debemos configurar dos objetos JSON. El objeto billingPlanAttribs contiene la información y el desglose de pago del plan de facturación al que podemos suscribir a los usuarios, y el objeto billingPlanUpdateAttributes contiene valores para establecer 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.
• definiciones_de_pago: Información sobre cómo debe funcionar y facturarse el plan. Más detalles sobre los campos [aquí][3].
• merchant_preferences: estructuras de tarifas adicionales, direcciones URL de redireccionamiento y configuraciones para el plan de suscripción. Más detalles sobre los campos [aquí][4].

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 de devolución contendrá información sobre el plan de facturación. Por el bien del ejemplo, solo necesitamos usar la identificación del plan de facturación para activar el plan para su uso.

A continuación, llamamos a billingPlan.update(...) y pasamos el 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 arriba), 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 de un usuario.

[2]: https://www.wikiod.com/es/paypal/primeros-pasos-con-paypal#Crear una aplicación y obtener la identificación del cliente/claves secretas [3]: https://developer.paypal.com/docs/api/#pagodefinición-objeto [4]: https://developer.paypal.com/docs/api/#merchantpreferences-object