In diesem Tutorial zeige ich Ihnen, wie Sie mit der PayPal-REST-API und C # Zahlungen tätigen können.  Alle Bibliotheken, die sie für verschiedene Sprachen wie Ruby, Node.js, Python, PHP haben, sind sehr ähnlich, so dass alle Konzepte hier für alle Bibliotheken gelten. 

Projektaufbau

Zu Beginn habe ich in Visual Studio 2015 ein MVC-Projekt erstellt: Datei> Neu> Projekt und ASP.NET-Anwendung auswählen. 

Wählen Sie die ASP.NET 5-Webanwendungsvorlage aus, die die neue MVC 6 verwendet.  Sie ist MVC 5 ähnlich, wenn Sie damit vertraut sind.

Wie Sie auf dem Foto sehen können, habe ich der Lösung einige Dateien und Ordner hinzugefügt.  Die wichtigsten zwei Dinge zu beachten sind:

1. In Referenzen habe ich den Ziel-DNX-Core 5.0 entfernt, was es uns ermöglichen würde, dieses Projekt unter Mac OS X oder Linux auszuführen, aber die von uns benötigte PayPal-Bibliothek wurde noch nicht aktualisiert. 
2. Ich habe den Ordner "Services" hinzugefügt, in dem ich die Logik für PayPal-Anrufe verpacken werde, damit wir die Controller schön und kurz halten können.

Installieren Sie PayPal SDK mit NuGet.  Klicken Sie mit der rechten Maustaste auf den Namen der Lösung und wählen Sie NuGet-Pakete verwalten. Suchen Sie dann nach "PayPal" und installieren Sie es. 

Erstellen Sie eine PayPal-App

Um unsere Anwendung mit PayPal zu integrieren, müssen wir zu PayPal-Entwicklern navigieren und dann unter REST-API-Apps auf App erstellen klicken.

Geben Sie Ihrer App einen Namen und wählen Sie ein Sandbox-Entwicklerkonto aus, das mit der App verknüpft ist.  Zu Testzwecken können Sie dann zu http://sandbox.paypal.com navigieren und sich mit den Anmeldedaten für die Sandbox anmelden, um das PayPal-Testkonto und die Transaktionen zu testen. 

Nach dem Klicken auf "App erstellen" sehen wir den Bestätigungsbildschirm mit der Client-ID und den geheimen Token. 

Kopieren Sie die Token clientId und clientSecret in appsettings.json, wie Sie im folgenden Screenshot sehen können: 

Zahlungen testen

PayPal stellt eine Sandbox-Umgebung zum Testen bereit.  Sie können Testkäufer- und Verkäuferkonten von dort erstellen.  Wenn Sie sich anmelden, verfügen Sie über ein Business-Konto in der Sandbox, das an Ihr Entwicklerkonto gebunden ist. 

Um ein neues Testkonto zu erstellen, melden Sie sich bei der Entwicklerseite an und klicken Sie dann auf die Registerkarte Dashboard und navigieren Sie zu Sandbox> Konten.  Hier können Sie die Liste der Testkonten sehen, wenn Sie Folgendes haben: 

Wenn Sie Ihre Testkonten noch nicht erstellt haben, klicken Sie rechts oben auf Konto erstellen, um mindestens ein persönliches Testkonto und ein Testgeschäftskonto zu erstellen.

Nachdem Sie die Testkonten erstellt haben, können Sie sich über www.sandbox.paypal.com mit der Test-E-Mail-Adresse und dem Passwort anmelden, die Sie den einzelnen Konten auf dem vorherigen Formular zugewiesen haben.  Dies ist sehr nützlich, um zu testen, ob die Gelder bei Ihrem "persönlichen Testkonto" auf Ihr "Testgeschäftskonto" überwiesen werden.  Jetzt können Sie mit der Integration in PayPal beginnen und testen, ob die Mittel von einem Konto auf ein anderes übertragen werden.

Einzel-PayPal-Zahlung 

PayPal bietet verschiedene Zahlungsmethoden an.  Sie können direkte Kreditkartenzahlungen verwenden, was bedeutet, dass Ihre Kunden die PayPal-Anmeldeseite oder -zusammenfassung nicht sehen können - alles geschieht auf Ihrer Website.  Sie müssen dafür PCI-kompatibel sein, und ich empfehle Stripe, da Sie nur SSL mit ihrer JavaScript-Bibliothek benötigen.  Auf der anderen Seite, um Zahlungen über PayPal-Zahlungen zu nehmen, dauert es drei Schritte: 

1. Geben Sie Zahlungsinformationen an, um eine Zahlung zu erstellen. 
2. Holen Sie sich die Zahlungsgenehmigung, indem Sie Ihren Kunden an PayPal weiterleiten, um die Transaktion zu genehmigen. 
3. Führen Sie die Zahlung aus, um die Beträge zu erfassen, nachdem PayPal Ihren Kunden auf Ihre Website weitergeleitet hat. 

In meinem MVC-Projekt habe ich im Ordner "Services" die PayPalPaymentService-Klasse erstellt, der ich diese Methoden hinzugefügt habe:

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

In diesem Aufruf werden einige Parameter übergeben: 

• Absicht: Drei mögliche Werte: "Verkauf" für sofortige Zahlungen, "Autorisieren", um eine Zahlung zu autorisieren, um später zu erfassen, oder "Bestellung", um einen Auftrag zu erstellen.  Wenn Sie die Autorisierung für eine später zu erfassende Zahlung erhalten, haben Sie 3 Tage Garantie, obwohl Sie versuchen können, die Zahlung bis zu 29 Tage später zu erfassen. 
• Payer: Quelle der Mittel für diese Zahlung, wobei die Zahlungsmethode PayPal-Wallet-Zahlung, Banklastschrift oder direkte Kreditkarte verwendet wird.
• Transaktionen: Hier wird der Betrag für die Zahlung angegeben und optional die Artikel angegeben, für die bezahlt wird.  Sie können bei Bedarf auch Zwischensumme, Versand und Steuern angeben. 
• Umleitungs-URLs: Geben Sie die URL an, an die PayPal Ihre Kunden nach einer Transaktion weiterleitet, sodass Sie Ihre Datenbank aktualisieren und eine Bestätigungsnachricht anzeigen können.

Die vorherigen Funktionen können von Ihrem Controller wie folgt verwendet werden: 

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

Wie Sie sehen können, habe ich drei Aktionen erstellt: 

• CreatePayment: Dies ist die Aktion, die die Zahlung auslöst.  Es ruft PayPal an, um die Zahlung zu erstellen, und leitet den Benutzer dann an PayPal weiter, um die Transaktion zu genehmigen. 
• PaymentSuccessful: Dies ist die Aktion, bei der PayPal unseren Kunden nach einer erfolgreichen Zahlung zurückleitet.  An diesem Punkt können wir die Zahlung ausführen, um die Gelder auf unser Händlerkonto zu übertragen. 
• PaymentCancelled: Bei dieser Aktion wird der Benutzer von PayPal umgeleitet, wenn der Benutzer den Genehmigungsprozess abbricht.  Zu diesem Zeitpunkt möchten Sie dem Kunden möglicherweise die Möglichkeit geben, es erneut zu versuchen oder sich mit Ihnen in Verbindung zu setzen.

Autorisieren Sie eine Zahlung, um sie später zu erfassen

Dieses Szenario ist dem vorherigen Fall sehr ähnlich.  Möglicherweise möchten Sie diese Methode verwenden, wenn Sie Vorbestellungen für ein Produkt durchführen möchten, das noch nicht verfügbar ist.  Die Schritte, um diese Zahlung zu erhalten, sind: 

1. Autorisierung der Zahlung: Der Parameter 'intent' für diesen Aufruf sollte 'authorize' lauten. 
2. Erfassung der Zahlung: Beachten Sie, dass Berechtigungen für bis zu 3 Tage garantiert sind. Sie können jedoch versuchen, eine Zahlung für bis zu 29 Tage zu erfassen. 

Um diese Zahlungsart zu implementieren, habe ich der Klasse PayPalPaymentService nur eine neue Methode hinzugefügt, um die Zahlung zu erfassen: 

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

Dann habe ich vom HomeController zwei neue Aktionen hinzugefügt, um diese Zahlungsart anzuzeigen:

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 ist die Aktion, die die Zahlung auslöst.  Es ist der vorherigen "CreatePayment" -Funktion sehr ähnlich, aber wir übergeben in diesem Fall "authorize" als den Parameter "intent". 
• AuthorizeSuccessful ist die Aktion, bei der Ihr Kunde nach erfolgreicher Genehmigung der Zahlung auf PayPal umgeleitet wird.  An dieser Stelle erfasse ich die Zahlung, aber Sie könnten die PaymentId in Ihrer Datenbank speichern und die Zahlung erfassen, wenn Sie müssen. 

In diesen Codebeispielen habe ich zur Vereinfachung die Zahlungsvariablenwerte fest codiert.  In Ihrer realen Anwendung werden Sie sie wahrscheinlich in Methoden einschließen, die all diese Werte als Variablen annehmen, so dass alles dynamisch festgelegt und wiederverwendet werden kann. 

Abonnements

Dies wird in PayPal als "Abrechnungspläne" bezeichnet. Sie können wiederkehrende Zahlungspläne erstellen und Ihre Kunden für einen Abrechnungsplan anmelden, indem Sie eine Abrechnungsvereinbarung erstellen.  Mit der PayPal REST API können Sie Fakturierungspläne erstellen, aktualisieren oder löschen. Dies ist etwas, das Sie verwenden können, wenn Sie ein Admin-Panel erstellen möchten, um diese Dinge für Ihr Unternehmen zu verwalten. 

Die Schritte zum Erstellen wiederkehrender Kosten für Ihre Kunden wären:

1. Erstellen Sie einen Abrechnungsplan und aktivieren Sie ihn.  Nachdem Sie einen Fakturierungsplan erstellt haben, befindet er sich in einem CREATED-Status.  Es muss aktiviert werden, indem eine PATCH-Anfrage gestellt wird. 
2. Legen Sie eine Abrechnungsvereinbarung an und führen Sie sie aus: Die Antwort auf den Aufruf zum Erstellen einer Abrechnungsvereinbarung enthält die Links zu approval_url und execute_url.  Wir müssen die Genehmigung für die Abrechnungsvereinbarung einholen und dann die Abrechnungsvereinbarung ausführen.

Abrechnungspläne

Erstellen Sie einen Abrechnungsplan

Erstellen Sie einen Fakturierungsplan, der die Abrechnungsperioden definiert.  Dies ist eine Zusammenfassung der Parameter, die zum Erstellen eines Plans übergeben werden müssen. 

• Name: Name des Abrechnungsplans.
• Beschreibung: Beschreibung des Fakturierungsplans. 
• Typ: Zulässige Werte sind 'FIXED' für eine festgelegte Anzahl wiederkehrender Zahlungen oder 'INFINITE' für einen Plan, der wiederholt wird, bis er manuell abgebrochen wird. 
• Merchant Preferences: Dies ist ein Objekt, das Präferenzen wie Setup-Gebühr, maximale Fehlerversuche einer Zahlung, Rückgabe-URL, Abbruch-URL, Benachrichtigungs-URL angibt, wobei PayPal den Nutzer nach einer Zahlung umleitet.    
• Zahlungsdefinitionen: Array mit Zahlungsdefinitionen für diesen Plan.  Normalerweise würde dieses Array eine oder zwei Zahlungsdefinitionen haben.  Wenn wir eine kostenlose Testversion oder eine Testversion zu einem reduzierten Preis anbieten möchten, richten wir zwei Zahlungsdefinitionen ein.  Die erste wird die Definition für die Probezeit sein, und die zweite Definition wäre die regelmäßige Zahlung.  Die Eigenschaften für eine Zahlungsdefinition sind Name, Typ (Probe oder Normal), Häufigkeit (Tag, Woche, Monat, Jahr), Häufigkeitsintervall (wenn wir die Frequenz auf "WOCHE" und das Frequenzintervall auf "1" setzen, sind wir Definieren einer wöchentlichen Zahlung), Betrag, der dem Kunden berechnet wird, und Zyklen ist die Anzahl der gesamten Zahlungen.  Charge Models dient dazu, die Versandkosten und Steuern zusätzlich zum Betragswert für den Plan anzugeben. 

Dies ist ein Code-Snippet, das zeigt, wie ein Fakturierungsplan erstellt wird:

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

Ein neu erstellter Fakturierungsplan hat den Status CREATED.  Aktivieren Sie es in den Status AKTIV, damit Ihre Kunden den Plan abonnieren können.  Um den Plan zu aktivieren, müssen wir eine PATCH-Anfrage machen: 

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

Wie Sie sehen können, sind PayPal-Bibliotheken ein direkter Wrapper für ihre REST-API, was gut ist, aber die API ist auch sehr komplex im Vergleich zu anderen wie Stripe.  Aus diesem Grund ist es wirklich eine gute Option, alle PayPal-Kommunikation in Objekte mit klareren und einfacheren APIs für unsere Anwendungen zu wickeln.  Hier können Sie sehen, wie dieser Code in mehrere Funktionen eingepackt ist und wie Parameter aussehen:

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

Aktualisierungsabrechnungsplan 

Sie können die Informationen für einen bestehenden Abrechnungsplan aktualisieren, indem Sie eine "PATCH" -Anfrage stellen.  Dies ist eine Funktion, die diesen Aufruf umschließt:

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

Um die Beschreibung des Fakturierungsplans zu aktualisieren, können wir diese Funktion aufrufen und die richtigen Parameter übergeben: 

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

Löschen eines Fakturierungsplans

Wenn Sie keine neuen Kunden für einen Abrechnungsplan akzeptieren möchten, sollten Sie sie idealerweise auf den Status "INAKTIV" aktualisieren.  Dies wirkt sich nicht auf bestehende Abrechnungsvereinbarungen für diesen Plan aus.  Dies kann einfach durch Aufruf der Funktion UpdateBillingPlan erfolgen: 

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

Abrechnungsvereinbarungen

Erstellen Sie eine Abrechnungsvereinbarung 

Sobald Sie einen oder mehrere Fakturierungspläne erstellt haben, möchten Sie damit beginnen, dass sich Kunden für Ihre Abonnementpläne anmelden.  Um dies zu tun, müssen Sie Ihre Kundendaten sammeln und eine Anfrage an PayPal stellen.  Um diese Funktionalität testen zu können, habe ich dem HomeController mehrere Aktionen hinzugefügt: 

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

• Abonnieren: Dies ist die erste Aktion, die aufgerufen wird.  Es wird ein Testabrechnungsplan erstellt und anschließend wird eine Abrechnungsvereinbarung (Abonnement) für diesen Plan erstellt, und der Benutzer wird zur Bestätigung der Zahlung an PayPal weitergeleitet. 
• SubscribeSuccess: Diese Aktion wird als 'Return URL' nach einem erfolgreichen Abonnement verwendet.  Die Übereinstimmungstoken-ID wird in der Abfragezeichenfolge übergeben, und wir verwenden dieses Token, um die Fakturierungsvereinbarung auszuführen und sie aktiv zu machen.
• SubscribeCancel: Diese Aktion wird als "URL abbrechen" verwendet.  Wenn aus irgendeinem Grund die Zahlung fehlschlägt oder Ihr Kunde die Zahlung auf PayPal storniert, wird der Benutzer zu dieser Aktion geleitet, und Sie müssen damit umgehen.  Vielleicht bieten Sie die Möglichkeit, es erneut zu versuchen. 

Wie Sie im vorherigen Code-Snippet sehen können, habe ich den Großteil der Funktionalität in verschiedene Methoden eingepackt.  Der erste ist "CreateBillingPlan", der im vorherigen Abschnitt erklärt wurde.  Der zweite ist "CreateBillingAgreement", mit dem ein Benutzer einen Plan abonniert: 

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

Die dritte Methode ist "ExecuteBillingAgreement".  Nach einer erfolgreichen Genehmigung des Abonnements verwenden wir das zurückgegebene Token, um das Abonnement zu aktivieren: 

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

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

Eine Abrechnungsvereinbarung aussetzen

Verwenden Sie diese Methode, um eine Vereinbarung auszusetzen: 

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

Reaktivieren Sie eine Abrechnungsvereinbarung 

Dieser ist dem vorherigen sehr ähnlich: 

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

Stornieren einer Abrechnungsvereinbarung 

Verwenden Sie diese Funktion, um einen Plan abzubrechen: 

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

Aktualisieren Sie eine Abrechnungsvereinbarung

Diese Option ist sehr begrenzt, und was ich von diesem Anruf erwarten würde, ist die Möglichkeit, den Abonnementplan zu ändern, um einen Kunden zu aktualisieren oder herabzustufen.  Dies wird in einem einzelnen Aufruf nicht unterstützt, wie es in Stripe ist.  Sie müssen dieses Szenario behandeln, indem Sie die aktuelle Vereinbarung aufheben und eine neue für Upgrades oder Downgrades erstellen.  Es ist nicht ideal, aber es könnte sich in Zukunft ändern. 

Fazit 

Dies ist eine Übersicht über die gängigsten Funktionen, die Benutzer zur Integration in PayPal verwenden.  Ihre API ist weitaus größer als die in diesem Artikel beschriebenen Integrationsmethoden. Sie können auch Rückerstattungen und teilweise Rückerstattungen ausgeben und sie haben viele verschiedene Optionen für Edge Cases in den in diesem Artikel behandelten Samples.  Wenn Sie mehr Details zu einer bestimmten Integration erfahren möchten, hinterlassen Sie einen Vorschlag in den Kommentaren.