Integración PayPal Parte 2: PayPal REST API

Spanish (Español) translation by Rodney Martinez (you can also view the original English article)

Final product image — What You'll Be Creating

En este tutorial, voy a mostrarle cómo puede tomar pagos usando la PayPal REST API y C#. Todas las bibliotecas que tienen para diferentes lenguajes de programación como Ruby, Node.js, Python, PHP son muy similares, así que todos los conceptos aquí aplica para todas las bibliotecas.

Configuración del Proyecto

Para iniciar, he creado un proyecto MVC en Visual Studio 2015: File > New > Project, y seleccione ASP.NET Application.

Seleccione la plantilla ASP.NET 5 Web Application, la cual usa la nueva MVC 6. Es parecido a MVC 5 si es que usted ya está familiarizado con ella.

Como puede ver en la foto debajo, he añadido algunos archivos y carpetas para la solución. Las dos cosas más importantes son:

En References, he eliminado el objeto DNX Core 5.0, que es el que nos permitiría ejecutar este proyecto en Mac OS X o Linux, pero la biblioteca de PayPal que necesitamos aún no ha sido actualizada.
He añadido la carpeta "Services", en donde voy a envolver la lógica para las llamadas PayPal, así que podemos conservar los controladores bien y al mínimo.

Instale PayPal SDK usando NuGet. Clic-derecho sobre el nombre de la solución y seleccione Manage NuGet Packages, y luego busque "PayPal" para instalarlo.

Crear una PayPal App

Para integrar nuestra aplicación con PayPal, necesitamos navegar a PayPal Developers, y luego debajo de REST API apps, hacer clic en Create App.

Asigne un nombre a su aplicación y escoja una cuenta Sandbox Deleloper que esté asociada con la app. Para propósitos de prueba, luego podemos navegar a http://sandbox.paypal.com e iniciar sesión con los detalles de registro Sandbox para probar la cuenta PayPal y las transacciones.

Después de hacer clic en Create App, veremos una pantalla de confirmación con el Client ID y Secret tokens.

Copie el clientId y and clientSecret tokens al archivo appsettings.json a como puede ver en la siguiente captura de pantalla:

Probando los Pagos

PayPal ofrece una opción de prueba para pagos; Sandbox environment for testing. Puede crear compradores de prueba y cuentas de vendedores desde aquí. Cuando usted se registre, tendrá una cuenta Business en el Sandbox que está unido a su cuenta developer.

Para probar una nueva cuenta de prueba, inicie sesión en Developer site, y luego haga clic en la pestaña Dashboard y diríjase hacia Sandbox > Accounts. Aquí puede ver la lista de las cuentas de prueba si es que tiene alguna:

Si todavía no ha creado sus cuentas de prueba, entonces continúe y haga clic en Create Account, en la parte superior a la derecha, para crear al menos una cuenta personal de prueba y una cuenta de prueba business.

Después de crear las cuentas de pruebas, puede iniciar sesión a través de www.sandbox.paypal.com con el correo electrónico y la clave de prueba que usted asigno a cada cuenta en el formulario anterior. Esto es muy útil para probar que cuando usted está comprando algo con la 'cuenta de prueba personal' los fondos están siendo transferidos a su 'cuenta de prueba business'. Ahora está listo para comenzar a integrar con PayPal y probar que los fondos son trasladados desde una cuenta hacia otra.

Único Pago PayPal

PayPal ofrece diferentes métodos de pago. Usted puede usar pagos directos de tarjetas de crédito, lo que significa que sus clientes no conseguirán ver la página de acceso PayPal o un resumen —ya que todo ocurre en su sitio web. Usted necesita ser un PCI obediente para esto y, le recomiendo usar Stripe, ya que sólo necesita SSL para usar su biblioteca JavaScript. Por otro lado, para tomar pagos por medio de PayPal payments, esto toma tres pasos:

Especificar una información de pago para crear un pago; create a payment.
Get payment approval, conseguir la aprobación del pago, para redireccionar a su cliente a PayPal para aprobar la transacción.
Execute the payment, ejecutar el pago para capturar los fondos después PayPal redirecciona a su cliente de vuelta a su sitio.

En mi proyecto MVC, en la carpeta Services, he creado la clase PayPalPaymentService donde he agregado estos métodos:

public static Payment CreatePayment(string baseUrl, string intent)
{
    // ### Api Context
    // Pass in a `APIContext` object to authenticate 
    // the call and to send a unique request id 
    // (that ensures idempotency). The SDK generates
    // a request id if you do not pass one explicitly. 
    var apiContext = PayPalConfiguration.GetAPIContext();

    // Payment Resource
    var payment = new Payment()
    {
        intent = intent,    // `sale` or `authorize`
        payer = new Payer() { payment_method = "paypal" },
        transactions = GetTransactionsList(),
        redirect_urls = GetReturnUrls(baseUrl, intent)
    };

    // Create a payment using a valid APIContext
    var createdPayment = payment.Create(apiContext);

    return createdPayment;
}

private static List<Transaction> GetTransactionsList()
{
    // A transaction defines the contract of a payment
    // what is the payment for and who is fulfilling it. 
    var transactionList = new List<Transaction>();

    // The Payment creation API requires a list of Transaction; 
    // add the created Transaction to a List
    transactionList.Add(new Transaction()
    {
        description = "Transaction description.",
        invoice_number = GetRandomInvoiceNumber(),
        amount = new Amount()
        {
            currency = "USD",
            total = "100.00",       // Total must be equal to sum of shipping, tax and subtotal.
            details = new Details() // Details: Let's you specify details of a payment amount.
            {
                tax = "15",
                shipping = "10",
                subtotal = "75"
            }
        },
        item_list = new ItemList()
        {
            items = new List<Item>()
            {
                new Item()
                {
                    name = "Item Name",
                    currency = "USD",
                    price = "15",
                    quantity = "5",
                    sku = "sku"
                }
            }
        }
    });
    return transactionList;
}

private static RedirectUrls GetReturnUrls(string baseUrl, string intent)
{
    var returnUrl = intent == "sale" ? "/Home/PaymentSuccessful" : "/Home/AuthorizeSuccessful";

    // Redirect URLS
    // These URLs will determine how the user is redirected from PayPal 
    // once they have either approved or canceled the payment.
    return new RedirectUrls()
    {
        cancel_url = baseUrl + "/Home/PaymentCancelled",
        return_url = baseUrl + returnUrl
    };
}

public static Payment ExecutePayment(string paymentId, string payerId)
{
    // ### Api Context
    // Pass in a `APIContext` object to authenticate 
    // the call and to send a unique request id 
    // (that ensures idempotency). The SDK generates
    // a request id if you do not pass one explicitly. 
    var apiContext = PayPalConfiguration.GetAPIContext();
    
    var paymentExecution = new PaymentExecution() { payer_id = payerId };
    var payment = new Payment() { id = paymentId };

    // Execute the payment.
    var executedPayment = payment.Execute(apiContext, paymentExecution);

    return executedPayment;
}

Hay algunos parámetros que están siendo añadidos en esta llamada:

Intent: Con tres valores posibles: 'sale' para pagos inmediatos, 'authorize' para autorizar un pago para tomarlo después o 'order' para crear una orden. Cuando consigue la authorization para una pago para capturarlo después, usted tiene 3 días garantizado, aunque usted puede intentar capturar el pago hasta 29 días después.
Payer: La fuente de los fondos para este pago y los métodos de pago que están siendo usados —PayPal Wallet payment, Bank Direct Debit or Direct Credit card.
Transactions: Esto es utilizado para especificar la cantidad de pago y, de manera opcional, especificar los objetos por los cuales el cliente está pagando. Además, puede especificar el subtotal, el envío y los impuesto si es necesario.
Redirect URLs: Especificar la URL para la cual PayPal redireccionará sus clientes después de la transacción, para que usted pueda actualizar su base de datos y mostrar un mensaje de confirmación.

Las funciones anteriores pueden ser utilizadas desde su controladores como éste:

public IActionResult CreatePayment()
{
    var payment = PayPalPaymentService.CreatePayment(GetBaseUrl(), "sale");
    
    return Redirect(payment.GetApprovalUrl());
}

public IActionResult PaymentCancelled()
{
    // TODO: Handle cancelled payment
    return RedirectToAction("Error");
}

public IActionResult PaymentSuccessful(string paymentId, string token, string PayerID)
{
    // Execute Payment
    var payment = PayPalPaymentService.ExecutePayment(paymentId, PayerID);

    return View();
}

Como usted puede ver, he creado tres acciones:

CreatePayment: Esta es la acción que activa el pago. Está haciendo una llamada a PayPal para crear el pago Payment, luego está redireccionando al usuario a PayPal para aprobar la transacción.
PaymentSuccessful: Esta es la acción donde PayPal redirecciona de vuelta a nuestro cliente después de una pago exitoso. En este punto podemos ejecutar el pago para conseguir que los fondos sean transferidos a nuestra cuenta merchant.
PaymentCancelled: Esta acción es donde el usuario es redireccionado desde PayPal si el usuario cancela el proceso de aprobación. En este momento, probablemente usted querrá dar la opción al cliente para tratar de nuevo o para contactarse con usted.

Autorice un Pago para Capturarlo Después

Este escenario es muy parecido al caso anterior. Tal vez querrá usar este método si está tratando de tomar pedidos reservados para un producto que aún no está disponible. Los pasos para conseguir este pago son:

Authorize the payment: autorizar el pago, el parámetro 'indent' para esta llamada debería ser 'authorize'.
Capture the payment: o capturar el pago, tenga en cuenta que las autorizaciones están garantizadas para más de 3 días, aunque usted puede intentar capturar un pago hasta más de 29 días.

Para implementar este tipo de pagos, solamente he agregado un método nuevo a la clase PayPalPaymentService para capturar el pago:

public static Capture CapturePayment(string paymentId)
{
    var apiContext = PayPalConfiguration.GetAPIContext();

    var payment = Payment.Get(apiContext, paymentId);
    var auth = payment.transactions[0].related_resources[0].authorization;

    // Specify an amount to capture.  By setting 'is_final_capture' to true, all remaining funds held by the authorization will be released from the funding instrument.
    var capture = new Capture()
    {
        amount = new Amount()
        {
            currency = "USD",
            total = "4.54"
        },
        is_final_capture = true
    };

    // Capture an authorized payment by POSTing to
    // URI v1/payments/authorization/{authorization_id}/capture
    var responseCapture = auth.Capture(apiContext, capture);

    return responseCapture;
}

Luego, desde el HomeController, he agregado dos acciones nuevas para mostrar este tipo de pago:

public IActionResult AuthorizePayment()
{
    var payment = PayPalPaymentService.CreatePayment(GetBaseUrl(), "authorize");
    
    return Redirect(payment.GetApprovalUrl());
}

public IActionResult AuthorizeSuccessful(string paymentId, string token, string PayerID)
{
    // Capture Payment
    var capture = PayPalPaymentService.CapturePayment(paymentId);

    return View();
}

AuthorizePayment es la acción que activa el pago. Es parecida a la función anterior 'CreatePayment', pero estamos pasando 'authorize' como el parámetro 'intent' en este caso.
AuthorizeSuccessful es la acción donde su cliente será redireccionado después de haber aprobado con éxito el pago en PayPal. En este punto estoy capturando el pago, pero usted podría guardar el pago en su base de datos y capturar el pago cuando usted lo necesite.

En estos códigos de muestra, por simpleza, he codificado los valores de las variables de pago. En su aplicación real, probablemente usted las envolverá en métodos que tomaran todos estos valores como variables para que todo pueda ser ajustado de forma dinámica y reutilizarlo.

Suscripciones

A esto se le llama "Billing Plans" en PayPal, Usando la PayPal REST API, usted puede crear, actualizar o eliminar planes de facturación, esto es algo que usted podría usar si usted quiere construir un panel de control para controlar estas cosas para su negocio.

Los pasos para crear cargos periódicos a sus clientes serían:

Create a billing plan, crear un plan de facturación y; activate it, activarlo. Después de crear un Billing Plan, éste está en una condición CREATED. Necesita ser activado para hacer una consulta PATH.
Create a billing agreement, crear un acuerdo de facturación y; execute it, ejecutarlo: La respuesta a la llamada para Create un acuerdo de facturación incluye los enlaces approval_url y execute_url. Necesitamos conseguir la aprobación para el acuerdo de facturación y luego ejecutar el acuerdo de facturación.

Planes de Facturación

Crear un Plan de Facturación

Crear un plan de facturación que defina los periodos de facturación. Esto es un resumen de los parámetros que necesitamos pasar para crear un plan.

Name: Nombre del plan de facturación.
Description: Una descripción del plan de facturación.
Type: Los valores permitidos son 'FIXED'; para un número fijo de pagos periódicos, o 'INFINITE' para un plan que se repite hasta que es cancelado manualmente.
Merchant Preferences: Este es un objeto que específica las preferencias tales como la configuración de la tarifa, máximos intentos fallados de un pago, devolver una URL, cancelar una URL, notificar URL, donde PayPal redireccionará al usuario después de un pago.
Payment Definitions: Un objeto Array de las definiciones de pago para este plan. Normalmente, este array tendría uno o dos definiciones de pagos. Si queremos ofrecer una versión gratuita o una prueba a un precio de descuento, entonces configuramos dos definiciones de pagos. El primero será la definición para el período de prueba, y la segunda definición sería para un pago regular. Las propiedades para una definición de pago Payment Definition son name, type (prueba o regular), frequency (día, semana, mes, año), frequency interval (si ajustamos la frequency a 'WEEK', es decir, semana, y la frequency interval a '1', entonces estamos definiendo un pago semanal), amount, la cantidad que se va a cargar a un cliente y cycles, que es el número total de pagos. Charge Models, es para especificar el costo de envío y el impuesto adicional para el valor de la cantidad para el plan.

Este es un fragmento de código que muestra como crear un Billing Plan:

// Define the plan and attach the payment definitions and merchant preferences.
// More Information: https://developer.paypal.com/webapps/developer/docs/api/#create-a-plan
var billingPlan = new Plan
{
    name = "Tuts+ Plus",
    description = "Monthly plan for courses.",
    type = "fixed",
    // Define the merchant preferences.
    // More Information: https://developer.paypal.com/webapps/developer/docs/api/#merchantpreferences-object
    merchant_preferences = new MerchantPreferences()
    {
        setup_fee = GetCurrency("0"), // $0
        return_url = "returnURL", // Retrieve from config
        cancel_url = "cancelURL", // Retrieve from config
        auto_bill_amount = "YES",
        initial_fail_amount_action = "CONTINUE",
        max_fail_attempts = "0"
    },
    payment_definitions = new List<PaymentDefinition>
    {
        // Define a trial plan that will only charge $9.99 for the first
        // month. After that, the standard plan will take over for the
        // remaining 11 months of the year.
        new PaymentDefinition()
        {
            name = "Trial Plan",
            type = "TRIAL",
            frequency = "MONTH",
            frequency_interval = "1",
            amount = GetCurrency("0"), // Free for the 1st month
            cycles = "1",
            charge_models = new List<ChargeModel>
            {
                new ChargeModel()
                {
                    type = "TAX",
                    amount = GetCurrency("1.65") // If we need to charge Tax
                },
                new ChargeModel()
                {
                    type = "SHIPPING",
                    amount = GetCurrency("9.99") // If we need to charge for Shipping
                }
            }
        },
        // Define the standard payment plan. It will represent a monthly
        // plan for $19.99 USD that charges once month for 11 months.
        new PaymentDefinition
        {
            name = "Standard Plan",
            type = "REGULAR",
            frequency = "MONTH",
            frequency_interval = "1",
            amount = GetCurrency("15.00"),
            // > NOTE: For `IFNINITE` type plans, `cycles` should be 0 for a `REGULAR` `PaymentDefinition` object.
            cycles = "11",
            charge_models = new List<ChargeModel>
            {
                new ChargeModel
                {
                    type = "TAX",
                    amount = GetCurrency("2.47")
                },
                new ChargeModel()
                {
                    type = "SHIPPING",
                    amount = GetCurrency("9.99")
                }
            }
        }
    }
};

// Get PayPal Config
var apiContext = PayPalConfiguration.GetAPIContext();

// Create Plan
plan.Create(apiContext);

Un plan de facturación recién creado está en una condición CREATED. Actívelo para la condición ACTIVE, para que sus clientes puedan suscribirse al plan. Para activar el plan, necesitamos hacer un PATCH request:

// Activate the plan
var patchRequest = new PatchRequest()
{
    new Patch()
    {
        op = "replace",
        path = "/",
        value = new Plan() { state = "ACTIVE" }
    }
};
plan.Update(apiContext, patchRequest);

Como puede ver, las bibliotecas PayPal son una envoltura directa sobre su REST API, lo cual es bueno, pero la API también es muy compleja comparada a otras como Stripe. Por esta razón, es una muy buena opción envolver por completo la comunicación PayPal en objetos con APIs claras y sencillas par nuestras aplicaciones. Aquí puede ver lo que esto código envolvió en múltiples funciones tomando parámetros como:

public static Plan CreatePlanObject(string planName, string planDescription, string returnUrl, string cancelUrl,
    string frequency, int frequencyInterval, decimal planPrice,
    decimal shippingAmount = 0, decimal taxPercentage = 0, bool trial = false, int trialLength = 0, decimal trialPrice = 0)
{
    // Define the plan and attach the payment definitions and merchant preferences.
    // More Information: https://developer.paypal.com/docs/rest/api/payments.billing-plans/
    return new Plan
    {
        name = planName,
        description = planDescription,
        type = PlanType.Fixed,

        // Define the merchant preferences.
        // More Information: https://developer.paypal.com/webapps/developer/docs/api/#merchantpreferences-object
        merchant_preferences = new MerchantPreferences()
        {
            setup_fee = GetCurrency("1"),
            return_url = returnUrl,
            cancel_url = cancelUrl,
            auto_bill_amount = "YES",
            initial_fail_amount_action = "CONTINUE",
            max_fail_attempts = "0"
        },
        payment_definitions = GetPaymentDefinitions(trial, trialLength, trialPrice, frequency, frequencyInterval, planPrice, shippingAmount, taxPercentage)
    };
}

private static List<PaymentDefinition> GetPaymentDefinitions(bool trial, int trialLength, decimal trialPrice,
    string frequency, int frequencyInterval, decimal planPrice, decimal shippingAmount, decimal taxPercentage)
{
    var paymentDefinitions = new List<PaymentDefinition>();

    if (trial)
    {
        // Define a trial plan that will charge 'trialPrice' for 'trialLength'
        // After that, the standard plan will take over.
        paymentDefinitions.Add(
            new PaymentDefinition()
            {
                name = "Trial",
                type = "TRIAL",
                frequency = frequency,
                frequency_interval = frequencyInterval.ToString(),
                amount = GetCurrency(trialPrice.ToString()),
                cycles = trialLength.ToString(),
                charge_models = GetChargeModels(trialPrice, shippingAmount, taxPercentage)
            });
    }

    // Define the standard payment plan. It will represent a 'frequency' (monthly, etc)
    // plan for 'planPrice' that charges 'planPrice' (once a month) for #cycles.
    var regularPayment = new PaymentDefinition
    {
        name = "Standard Plan",
        type = "REGULAR",
        frequency = frequency,
        frequency_interval = frequencyInterval.ToString(),
        amount = GetCurrency(planPrice.ToString()),
        // > NOTE: For `IFNINITE` type plans, `cycles` should be 0 for a `REGULAR` `PaymentDefinition` object.
        cycles = "11",
        charge_models = GetChargeModels(trialPrice, shippingAmount, taxPercentage)
    };
    paymentDefinitions.Add(regularPayment);

    return paymentDefinitions;
}

private static List<ChargeModel> GetChargeModels(decimal planPrice, decimal shippingAmount, decimal taxPercentage)
{
    // Create the Billing Plan
    var chargeModels = new List<ChargeModel>();
    if (shippingAmount > 0)
    {
        chargeModels.Add(new ChargeModel()
        {
            type = "SHIPPING",
            amount = GetCurrency(shippingAmount.ToString())
        });
    }
    if (taxPercentage > 0)
    {
        chargeModels.Add(new ChargeModel()
        {
            type = "TAX",
            amount = GetCurrency(String.Format("{0:f2}", planPrice * taxPercentage / 100))
        });
    }

    return chargeModels;
}

Actualizando el Plan de Facturación

Usted puede actualizar la información para un plan de facturación que ya existe por medio de una solicitud 'PATCH'. Esta es una función que envuelve esa llamada:

public static void UpdateBillingPlan(string planId, string path, object value)
{
    // PayPal Authentication tokens
    var apiContext = PayPalConfiguration.GetAPIContext();

    // Retrieve Plan
    var plan = Plan.Get(apiContext, planId);

    // Activate the plan
    var patchRequest = new PatchRequest()
    {
        new Patch()
        {
            op = "replace",
            path = path,
            value = value
        }
    };
    plan.Update(apiContext, patchRequest);
}

Para actualizar la descripción del Billing Plan, plan de facturación, entonces podemos llamar esta función y pasar los parámetros correctos:

1	UpdateBillingPlan(
2	planId: "P-5FY40070P6526045UHFWUVEI",
3	path: "/",
4	value: new Plan { description = "new description" });

Borrar un Plan de Facturación

Lo ideal, cuando no quiera aceptar clientes nuevos a un plan de facturación 'Billing Plan', es que querrá actualizarlo a la condición 'INACTIVE'. Esto no afectará a los acuerdos de facturación que ya existen en este plan: Esto se puede hacer simplemente haciendo una llamada a la función UpdateBillingPlan:

1	UpdateBillingPlan(
2	planId: "P-5FY40070P6526045UHFWUVEI",
3	path: "/",
4	value: new Plan { state = "INACTIVE" });

Acuerdos de Facturación

Creando un Acuerdo de Facturación

Una vez que ha creado uno o más planes de facturación, querrá empezar que los clientes se inscriban a sus planes de suscripción. Para hacer esto, necesita coleccionar los detalles de sus clientes y hacer una solicitud a PayPal. Para probar esta funcionalidad, he agregado varias acciones al HomeController:

public IActionResult Subscribe()
{
    var plan = PayPalSubscriptionsService.CreateBillingPlan("Tuts+ Plan", "Test plan for this article", GetBaseUrl());

    var subscription = PayPalSubscriptionsService.CreateBillingAgreement(plan.id, 
        new PayPal.Api.ShippingAddress
        {
            city = "London", 
            line1 = "line 1",
            postal_code = "SW1A 1AA",
            country_code = "GB"
        }, "Pedro Alonso", "Tuts+", DateTime.Now);
    
    return Redirect(subscription.GetApprovalUrl());
}

public IActionResult SubscribeSuccess(string token)
{
    // Execute approved agreement
    PayPalSubscriptionsService.ExecuteBillingAgreement(token);

    return View();
}

public IActionResult SubscribeCancel(string token)
{
    // TODO: Handle cancelled payment
    return RedirectToAction("Error");
}

Subscribe: Esta es la primera acción que es llamada. Esto crea una prueba de un plan de facturación 'Billing Plan' y luego una acuerdo de facturación 'Billing Agreement' (suscripción) para que ese plan sea creado y el usuario sea redireccionado hacia PayPal para confirmar el pago.
SubscribeSuccess: Esta acción es uno usado como 'Return URL' después de una suscripción exitosa. El token identificador del acuerdo es pasado en la cadena de consulta, y usamos este token para ejecutar el acuerdo de facturación y activarlo.
SubscribeCancel: Esta acción es una que usamos para 'Cancel URL'. Si por alguna razón el pago falla, o su cliente cancela el pago en PayPal, entonces el usuario es llevado a esta acción y usted necesita controlar esto. Tal vez ofrecer la opción de probar otra vez.

Como puede ver en el fragmento de código anterior, he envuelto la mayor parte de la funcionalidad en varios métodos. El primero método es "CreateBillingPlan", que ya explicamos como funciona en la sección anterior. El segundo método es "CreateBillingAgreement" que es usado para suscribir un usuario a un plan:

public static Agreement CreateBillingAgreement(string planId, ShippingAddress shippingAddress, 
    string name, string description, DateTime startDate)
{
    // PayPal Authentication tokens
    var apiContext = PayPalConfiguration.GetAPIContext();

    var agreement = new Agreement()
    {
        name = name,
        description = description,
        start_date = startDate.ToString("yyyy-MM-ddTHH:mm:ss") + "Z",
        payer = new Payer() { payment_method = "paypal" },
        plan = new Plan() { id = planId },
        shipping_address = shippingAddress
    };
    
    var createdAgreement = agreement.Create(apiContext);
    return createdAgreement;
}

El tercer método es "ExecuteBillingAgreement". Después de una suscripción exitosa aprobada, usamos el token devuelto para activar la suscripción.

public static void ExecuteBillingAgreement(string token)
{
    // PayPal Authentication tokens
    var apiContext = PayPalConfiguration.GetAPIContext();

    var agreement = new Agreement() { token = token };
    var executedAgreement = agreement.Execute(apiContext);
}

Suspender un Acuerdo de Facturación

Use este método para suspender un acuerdo:

public static void SuspendBillingAgreement(string agreementId)
{
    var apiContext = PayPalConfiguration.GetAPIContext();

    var agreement = new Agreement() { id = agreementId };
    agreement.Suspend(apiContext, new AgreementStateDescriptor()
        { note = "Suspending the agreement" });
}

Reactivar un Acuerdo de Facturación

Este método es muy parecido al anterior:

public static void ReactivateBillingAgreement(string agreementId)
{
    var apiContext = PayPalConfiguration.GetAPIContext();

    var agreement = new Agreement() { id = agreementId };
    agreement.ReActivate(apiContext, new AgreementStateDescriptor()
        { note = "Reactivating the agreement" });
}

Cancelar un Acuerdo de Facturación

Use esta función para cancelar un plan:

public static void CancelBillingAgreement(string agreementId)
{
    var apiContext = PayPalConfiguration.GetAPIContext();

    var agreement = new Agreement() { id = agreementId };
    agreement.Cancel(apiContext, new AgreementStateDescriptor()
        { note = "Cancelling the agreement" });
}

Actualice un Acuerdo de Facturación

Esta opción es muy limitada y lo que esperaría desde esta llamada es la posibilidad de cambiar el plan de suscripción, para actualizaciones o bajar la categoría de un cliente. Esto no tiene respaldo en una llamada única como ocurre en Stripe. Necesita manejar este escenario para cancelar el acuerdo actual y crear uno nuevo para actualizaciones o para cambio de categoría. No es lo ideal, pero podría cambiar en el futuro.

Conclusión

Esto es un resumen de las funciones más comunes que las personas pueden usar para integrar con PayPal. Su API es mucho mayor que los métodos de integración que se han explicado en este artículo, además, usted puede emitir reembolsos y reembolsos parciales, y éstos tienen muchas opciones diferentes para muchos casos en las muestras que hemos abordado en este artículo. Si está más interesado en conseguir más detalles acerca de cualquier integración específica, por favor, deje una sugerencia en los comentarios.