PayPal Integration Del 2 PayPal REST API

Vad du ska skapa

I denna handledning kommer jag att visa dig hur du kan ta ut betalningar med PayPal REST API och C #. Alla bibliotek som de har för olika språk som Ruby, Node.js, Python, PHP är mycket lika, så alla begrepp gäller här för alla bibliotek.

Projektinställningar

Till att börja med har jag skapat ett MVC-projekt i Visual Studio 2015: Arkiv> Nytt> Projekt, och välj ASP.NET Application.

Välj ASP.NET 5 webbapplikation Mall, som använder den nya MVC 6. Den liknar MVC 5 om du är bekant med den.

Som du kan se i bilden nedan har jag lagt till några filer och mappar till lösningen. De viktigaste två sakerna att märka är:

I referenser Jag har tagit bort målet DNX Core 5.0, vilket gör det möjligt för oss att köra det här projektet i Mac OS X eller Linux, men det PayPal-bibliotek som vi behöver har inte uppdaterats än.
Jag har lagt till mappen "Tjänster", där jag ska lägga in logiken för PayPal-samtal, så vi kan hålla kontrollerna snygga och korta.

Installera PayPal SDK med NuGet. Högerklicka på namnet på lösningen och välj Hantera NuGet-paket, och sök sedan efter "PayPal" och installera den.

Skapa en PayPal-app

För att integrera vår ansökan med PayPal måste vi navigera till PayPal Developers, och sedan under REST API-appar, Klicka på Skapa app.

Ge din app ett namn och välj ett sandboxutvecklarkonto som är kopplat till appen. För teständamål kan vi sedan navigera till http://sandbox.paypal.com och logga in med information om sandlåda inloggning för att se testet PayPal-konto och transaktioner.

Efter att ha klickat på Skapa app, vi ser bekräftelsesskärmen med klient-ID och hemliga tokens.

Kopiera klientId och clientSecret tokens till appsettings.json, som du kan se på skärmdumpen nedan:

Testa betalningar

PayPal tillhandahåller en Sandbox-miljö för testning. Du kan skapa testköpare och säljarkonton därifrån. När du registrerar dig har du ett Business-konto i Sandboxen som är knuten till ditt utvecklarkonto.

För att skapa ett nytt testkonto, logga in på utvecklarwebbplatsen och klicka sedan på instrumentbräda fliken och navigera till Sandbox> Konton. Här kan du se listan över testkonton om du har något:

Om du inte har skapat dina testkonton ännu, fortsätt och klicka på Skapa konto, högst upp till höger, för att skapa minst ett testpersonligt konto och ett testaffärskonto.

Efter att du skapat testkonton kan du logga in via www.sandbox.paypal.com med testadressens e-postadress och lösenord som du tilldelade varje konto på föregående formulär. Det här är verkligen användbart att testa att när du köper något med ditt personliga testkonto, överförs medel till ditt testkontokonto. Nu är du redo att börja integrera med PayPal och testa att pengarna flyttar från ett konto till ett annat.

Enkel PayPal-betalning

PayPal erbjuder olika betalningsmetoder. Du kan använda direktkortsbetalningar, vilket innebär att dina kunder inte får se PayPal-inloggningssidan eller sammanfattningen - det händer allt på din webbplats. Du måste vara PCI-kompatibel för detta, och jag rekommenderar att du använder Stripe, eftersom du bara behöver SSL med hjälp av deras JavaScript-bibliotek. Å andra sidan, för att betala via PayPal betalningar, tar det tre steg:

Ange betalningsinformation till skapa en betalning.
Få betalningsgodkännande, genom att omdirigera din kund till PayPal för att godkänna transaktionen.
Utför betalningen för att fånga pengarna efter PayPal omdirigerar din kund tillbaka till din webbplats.

I mitt MVC-projekt, i tjänster mappen har jag skapat klassen PayPalPaymentService där jag har lagt till följande metoder:

offentliga statiska Betalning SkapaPayment (strängbasUrl, strängintentiv) // ### Api Context // Passa in i ett 'APIContext'-objekt för att autentisera // samtalet och skicka ett unikt förfrågnings-id // (som säkerställer idempotency). SDK genererar // ett förfrågnings-ID om du inte skickar en explicit. var apiContext = PayPalConfiguration.GetAPIContext (); // Betalningsresurs var betalning = ny Betalning () intent = intent, // "försäljning" eller "auktorisera" betalare = ny betalare () payment_method = "paypal", transaktioner = GetTransactionsList (), redirect_urls = GetReturnUrls (baseUrl , avsikt); // Skapa en betalning med en giltig APIContext var createdPayment = payment.Create (apiContext); returnera createdPayment;  privat statisk lista GetTransactionsList () // En transaktion definierar kontraktet för en betalning // vad är betalningen för och vem som uppfyller den. var transactionList = ny lista(); // API för betalningsskapande kräver en lista över Transaktion; // Lägg till den skapade Transaktionen till en List-transaktionslista.Add (Ny transaktion () Description = "Transaktionsbeskrivning.", faktura_number = GetRandomInvoiceNumber (), belopp = nytt belopp () currency = "USD", totalt = "100,00" , // Total måste vara lika med summan av frakt, skatt och subtotal. Detaljer = nya detaljer () // detaljer: Låt oss ange detaljer för ett betalningsbelopp. Tax = "15", shipping = "10", subtotal = "75", item_list = new ItemList () items = new List() nytt objekt () name = "objektnamn", valuta = "USD", pris = "15", kvantitet = "5", sku = "sku"); returnera transaktionslista;  privata statiska RedirectUrls GetReturnUrls (strängbasUrl, strängintentiv) var returnUrl = intent == "sale"? "/ Hem / PaymentSuccessful": "/ Home / AuthorizeSuccessful"; // Omdirigera URLS // Dessa webbadresser bestämmer hur användaren omdirigeras från PayPal // när de antingen har godkänt eller avbokat betalningen. returnera nya RedirectUrls () cancel_url = baseUrl + "/ Hem / PaymentCancelled", return_url = baseUrl + returnUrl;  statisk statisk betalningsexekveringsbetalning (strängbetalningId, strängbetalareId) // ### Api Context // Passa in i ett "APIContext" -objekt för att autentisera // samtalet och skicka ett unikt förfrågnings-id // (som säkerställer idempotency). SDK genererar // ett förfrågnings-ID om du inte skickar en explicit. var apiContext = PayPalConfiguration.GetAPIContext (); var paymentExecution = new PaymentExecution () payer_id = payerId; var payment = new Betalning () id = paymentId; // Utför betalningen. var executedPayment = payment.Execute (apiContext, paymentExecution); returnera executedPayment;

Det finns några parametrar som skickas i detta samtal:

Avsikt: Tre möjliga värden: "försäljning" för omedelbara betalningar, "auktorisera" att tillåta en betalning att fånga senare eller "beställa" för att skapa en beställning. När du får tillstånd För en betalning att fånga senare, har du 3 dagar garanterad, även om du kan försöka få upp betalningen upp till 29 dagar senare.
betalare: Källa till fonderna för denna betalning, betalningsmetod som används - PayPal-betalning med betalning, Bankdirekt eller Direktkreditkort.
transaktioner: Detta används för att ange beloppet för betalningen och eventuellt ange vilka betalningar som ska betalas. Du kan också ange subtotal, frakt och moms om det behövs.
Omdirigeringsadresser: Ange webbadressen till vilken PayPal ska omdirigera dina kunder efter en transaktion, så att du kan uppdatera din databas och visa ett bekräftelsemeddelande.

De tidigare funktionerna kan användas från din styrenhet så här:

offentlig IActionResult CreatePayment () var payment = PayPalPaymentService.CreatePayment (GetBaseUrl (), "sale"); returnera omdirigering (payment.GetApprovalUrl ());  offentliga IActionResult PaymentCancelled () // TODO: Hantera avbeställd betalningsåterkomst RedirectToAction ("Error");  offentlig IActionResult PaymentSuccessful (strängbetalningId, strängtoken, sträng PayerID) // Execute Payment var payment = PayPalPaymentService.ExecutePayment (paymentId, PayerID); returnera Visa ();

Som du kan se har jag skapat tre åtgärder:

CreatePayment: Detta är åtgärden som utlöser betalningen. Det ringer till PayPal för att skapa Betalningen, och omdirigerar sedan användaren till PayPal för att godkänna transaktionen.
Betalning genomförd: Detta är åtgärden där PayPal omdirigerar vår kund efter en framgångsrik betalning. Vid denna tidpunkt kan vi genomföra betalningen för att få pengarna överförda till vårt säljarkonto.
PaymentCancelled: Den här åtgärden är där användaren omdirigeras från PayPal om användaren avbryter godkännandeprocessen. Vid den här tiden kommer du förmodligen att ge kunden möjlighet att försöka igen eller komma i kontakt med dig.

Godkänn en betalning för att fånga senare

Detta scenario liknar det föregående fallet. Du kanske vill använda den här metoden om du försöker ta förbeställningar för en produkt som inte är tillgänglig än. Stegen för att få denna betalning är:

Godkänn betalningen: Parametern "avsikt" för detta samtal bör vara "auktorisera".
Fånga betalningen: Tänk på att auktorisationer är garanterade i upp till 3 dagar, även om du kan försöka fånga en betalning i upp till 29 dagar.

För att genomföra denna typ av betalning har jag bara lagt till en ny metod för klassen PayPalPaymentService för att fånga betalningen:

statisk statisk Capture CapturePayment (strängbetalningId) var apiContext = PayPalConfiguration.GetAPIContext (); var payment = Payment.Get (apiContext, paymentId); var auth = payment.transactions [0] .related_resources [0] .authorization; // Ange ett belopp för att fånga. Genom att sätta 'is_final_capture' till sant kommer alla återstående medel som innehas av auktoriseringen att frigöras från finansieringsinstrumentet. var capture = new Capture () summa = nytt belopp () currency = "USD", totalt = "4.54", is_final_capture = true; // Fånga en auktoriserad betalning med POSTing till // URI v1 / betalningar / godkännande / authorization_id / capture var responseCapture = auth.Capture (apiContext, capture); returnera responseCapture;

Sedan från HomeController har jag lagt till två nya åtgärder för att visa denna typ av betalning:

offentlig IActionResult AuthorizePayment () var payment = PayPalPaymentService.CreatePayment (GetBaseUrl (), "authorize"); returnera omdirigering (payment.GetApprovalUrl ());  offentliga IActionResult AuthorizeSuccessful (strängbetalningId, strängtoken, sträng PayerID) // Capture Payment var capture = PayPalPaymentService.CapturePayment (paymentId); returnera Visa ();

AuthorizePayment är åtgärden som utlöser betalningen. Det ligner mycket på den tidigare "CreatePayment" -funktionen, men vi överlåter "godkänna" som avsiktsparametern i det här fallet.
AuthorizeSuccessful är den åtgärd där din kund omdirigeras efter att ha godkänt betalningen på PayPal. Vid denna tidpunkt tar jag in betalningen, men du kan spara betalningen i din databas och fånga betalningen när du behöver.

I dessa kodprover har jag, för enkelhet, kodat värdena för betalningsvariabler. I din riktiga applikation kommer du förmodligen att sätta dem i metoder som tar alla dessa värden som variabler så att allt kan ställas in dynamiskt och återanvändas.

Prenumerationer

Detta kallas "Faktureringsplaner" i PayPal. Du kan skapa återkommande betalningsplaner och prenumerera dina kunder på en faktureringsplan genom att skapa ett faktureringsavtal. Med PayPal REST API kan du skapa, uppdatera eller ta bort faktureringsplaner. Det här är något du kan använda om du vill bygga en adminpanel för att hantera dessa saker för ditt företag.

Stegen för att skapa återkommande avgifter till dina kunder är:

Skapa en faktureringsplan och aktivera den. När du har skapat en faktureringsplan, är den i en CREATED-status. Det måste aktiveras genom att göra en PATCH-förfrågan.
Skapa ett faktureringsavtal och genomföra det: Svaret på samtalet Skapa ett faktureringsavtal innehåller länkarna till approval_url och execute_url. Vi måste godkänna faktureringsavtalet och genomföra faktureringsavtalet.

Faktureringsplaner

Skapa en faktureringsplan

Skapa en faktureringsplan som definierar faktureringsperioderna. Detta är en sammanfattning av parametrarna som vi måste övergå för att skapa en plan.

Namn: Namn på faktureringsplanen.
Beskrivning: Beskrivning av faktureringsplanen.
Typ: Tillåtna värden är "FIXED" för ett bestämt antal återkommande betalningar, eller "INFINITE" för en plan som återkommer till det manuellt avbrutits.
Merchant Preferences: Det här är ett objekt som anger inställningar som inställningsavgift, maximala försök med betalning, returadress, avbryt webbadress, meddela URL, där PayPal omdirigerar användaren efter en betalning.
Betalningsdefinitioner: Array av betalningsdefinitioner för denna plan. Normalt skulle denna array ha en eller två betalningsdefinitioner. Om vi vill erbjuda en kostnadsfri försök eller en rättegång till ett rabatterat pris, ställer vi upp två betalningsdefinitioner. Den första kommer att vara definitionen för försöksperioden, och den andra definitionen skulle vara den vanliga betalningen. Egenskaperna för en betalningsdefinition är namn, typ (prov eller regelbunden), frekvens (dag, vecka, månad, år), frekvensintervall (om vi ställer frekvensen till "WEEK" och frekvensintervallet till "1" definierar vi en veckovis betalning), belopp att debitera kunden, och cykler är antalet totala betalningar. Laddningsmodeller är att ange fraktkostnad och skatt tilläggsbeloppet för planen.

Det här är en kodbit som visar hur man skapar en faktureringsplan:

// Definiera planen och bifoga betalningsdefinitioner och handelsinställningar. // Mer information: https://developer.paypal.com/webapps/developer/docs/api/#create-a-plan var billingPlan = ny Plan name = "Tuts + Plus", beskrivning = "Månadsplan för kurser. ", typ =" fixed ", // Definiera köpoptionens preferenser. // Mer information: https://developer.paypal.com/webapps/developer/docs/api/#merchantpreferences-object merchant_preferences = nya MerchantPreferences () setup_fee = GetCurrency ("0"), // $ 0 return_url = "returnURL ", // Hämta från config cancel_url =" cancelURL ", // Hämta från config auto_bill_amount =" YES ", initial_fail_amount_action =" CONTINUE ", max_fail_attempts =" 0 ", payment_definitions = ny lista // Definiera en provplan som endast tar ut $ 9,99 för den första // månaden. Efter det kommer standardplanen att ta över för // resterande 11 månader av året. new PaymentDefinition () name = "Trial Plan", typ = "TRIAL", frekvens = "MÅNAD", frequency_interval = "1", amount = GetCurrency ("0"), // Gratis för 1: a månadscykler = "1 ", charge_models = ny lista new ChargeModel () type = "TAX", belopp = GetCurrency ("1.65") // Om vi måste debitera Skatt, nya ChargeModel () type = "SHIPPING", belopp = GetCurrency ("9.99") / / Om vi behöver ta betalt för Frakt, // Definiera standardbetalningsplanen. Det kommer att representera en månads // plan för $ 19,99 USD som debiteras en gång i månaden i 11 månader. ny Betalningsdefinition name = "Standardplan", typ = "REGULAR", frekvens = "MÅNAD", frequency_interval = "1", amount = GetCurrency ("15.00"), //> OBS: För 'IFNINITE' cykler "ska vara 0 för ett" REGULAR "PaymentDefinition" -objekt. cycles = "11", charge_models = new List new ChargeModel type = "TAX", belopp = GetCurrency ("2,47"), ny ChargeModel () type = "SHIPPING", summa = GetCurrency ("9.99"); // Hämta PayPal Config var apiContext = PayPalConfiguration.GetAPIContext (); // Skapa Plan plan. Skapa (ApiContext);

En nyskapad faktureringsplan är i en CREATED-status. Aktivera det i AKTIVT tillstånd, så dina kunder kan prenumerera på planen. För att aktivera planen måste vi göra en PATCH-förfrågan:

// Aktivera planen var patchRequest = new PatchRequest () new Patch () op = "ersätt", sökväg = "/", värde = ny Plan () state = "ACTIVE"; planera. Uppdatera (apiContext, patchRequest);

Som du kan se är PayPal-bibliotek ett direktomslag över deras REST API, vilket är bra, men API är också väldigt komplext jämfört med andra som Stripe. Av detta skäl är det verkligen ett bra alternativ att paketera all PayPal-kommunikation i objekt med tydligare och enklare API för våra applikationer. Här kan du se vad den här koden förpackas i flera funktioner som ser parametrar ut:

statisk plan SkapaPlanObject (strängplanName, strängplanBeskrivning, strängåterkomstUrl, strängbrytningUrl, strängfrekvens, intfrekvensInterval, decimalplanPris, decimalavsättningAmount = 0, decimal skattPercentage = 0, boolförsök = fel, int trialLength = 0, decimalprovPrice = 0 ) // Definiera planen och bifoga betalningsdefinitioner och handelsinställningar. // Mer information: https://developer.paypal.com/docs/rest/api/payments.billing-plans/ returnera ny plan name = planName, description = planDescription, type = PlanType.Fixed, // Definiera säljaren preferenser. // Mer information: https://developer.paypal.com/webapps/developer/docs/api/#merchantpreferences-object merchant_preferences = nya 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 (försök, trialLength, trialPrice, frekvens, frequencyInterval, planPris, fraktOmount, skattPercentage);  privat statisk lista GetPaymentDefinitions (boolprovning, int trialLength, decimal trialPrice, strängfrekvens, int frequencyInterval, decimalplanPris, decimalavsättningAmount, decimalskattPercentage) var paymentDefinitions = new List(); om (försök) // Definiera en provplan som tar ut 'trialPrice' för 'trialLength' // Efter det kommer standardplanen att ta över. paymentDefinitions.Add (new PaymentDefinition () name = "Trial", typ = "TRIAL", frekvens = frekvens, frequency_interval = frequencyInterval.ToString (), mängd = GetCurrency (trialPrice.ToString ()), cycles = trialLength.ToString ), charge_models = GetChargeModels (trialPrice, shippingAmount, taxPercentage));  // Definiera standardbetalningsplanen. Det kommer att representera en "frekvens" (månadsvis etc) // plan för "planpris" som tar ut "planpris" (en gång i månaden) för #cyklar. var regularPayment = new PaymentDefinition name = "Standardplan", typ = "REGULAR", frekvens = frekvens, frequency_interval = frequencyInterval.ToString (), belopp = GetCurrency (planPrice.ToString ()), //> OBS: För 'IFNINITE "typplaner, cykler" bör vara 0 för ett "REGULAR" PaymentDefinition "-objekt. cycles =" 11 ", charge_models = GetChargeModels (trialPrice, shippingAmount, taxPercentage); betalningsdefinitioner.Add (regularPayment); returnera betalningsdefinitioner; Lista GetChargeModels (decimalplanPris, decimalavsättningAmount, decimalskattPercentage) // Skapa faktureringsplanen var chargeModels = ny lista(); om (shippingAmount> 0) chargeModels.Add (new ChargeModel () type = "SHIPPING", summa = GetCurrency (shippingAmount.ToString ()));  if (taxPercentage> 0) chargeModels.Add (new ChargeModel () type = "TAX", belopp = GetCurrency (String.Format ("0: f2", planPris * skattPercentage / 100)));  returavgiftModeller;

Uppdatera Faktureringsplan

Du kan uppdatera informationen för en befintlig faktureringsplan genom att göra en "PATCH" -förfrågan. Det här är en funktion som sveper det samtalet:

offentlig statisk tomgång UpdateBillingPlan (strängplanId, strängväg, objektvärde) // PayPal Authentication tokens var apiContext = PayPalConfiguration.GetAPIContext (); // Hämta Plan var plan = Plan.Get (apiContext, planId); // Aktivera planen var patchRequest = new PatchRequest () new Patch () op = "ersätt", sökväg = väg, värde = värde; planera. Uppdatera (apiContext, patchRequest);

För att uppdatera beskrivningen av Faktureringsplanen kan vi ringa den här funktionen och skicka rätt parametrar:

UpdateBillingPlan (plan: "P-5FY40070P6526045UHFWUVEI", sökväg: "/", värde: ny Plan description = "new description");

Ta bort en faktureringsplan

Helst, när du inte vill acceptera nya kunder till en Faktureringsplan, vill du uppdatera den till "INAKTIVT" -läget. Detta kommer inte att påverka befintliga faktureringsavtal på denna plan. Detta kan göras enkelt genom att ringa UpdateBillingPlan-funktionen:

UpdateBillingPlan (plan: "P-5FY40070P6526045UHFWUVEI", sökväg: "/", värde: ny Plan state = "INACTIVE");

Faktureringsavtal

Skapa en faktureringsöverenskommelse

När du har skapat en eller flera faktureringsplaner vill du börja få kunder att anmäla dig till dina prenumerationsplaner. För att kunna göra detta måste du samla dina kunduppgifter och göra en förfrågan till PayPal. För att kunna testa denna funktion har jag lagt till flera åtgärder till HomeController:

offentlig IActionResult Subscribe () var plan = PayPalSubscriptionsService.CreateBillingPlan ("Tuts + Plan", "Testplan för denna artikel", GetBaseUrl ()); var abonnemang = PayPalSubscriptionsService.CreateBillingAgreement (plan.id, ny PayPal.Api.ShippingAddress city = "London", line1 = "linje 1", postal_code = "SW1A 1AA", country_code = "GB", "Pedro Alonso" "Tuts +", DateTime.Now); returnera omdirigering (abonnement.GetApprovalUrl ());  offentlig IActionResult SubscribeSuccess (strängtoken) // Utför godkänt avtal PayPalSubscriptionsService.ExecuteBillingAgreement (token); returnera Visa ();  offentlig IActionResult SubscribeCancel (strängtoken) // TODO: Hantera avbrutet betalningsavkastning RedirectToAction ("Error");

Prenumerera: Detta är den första åtgärden som kallas. Det skapar en testfaktureringsplan, och sedan skapas ett faktureringsavtal (abonnemang) till den planen och användaren vidarebefordras till PayPal för att bekräfta betalningen.
SubscribeSuccess: Den här åtgärden är den som används som "Returadress" efter en framgångsrik prenumeration. Avtalets token-identifierare skickas i frågesträngen, och vi använder denna token för att utföra faktureringsavtalet och aktivera det.
SubscribeCancel: Den här åtgärden är den som används som "Avbryt URL". Om betalningen misslyckas eller om kunden avbryter betalningen på PayPal, tas användaren till den här åtgärden och du måste hantera det här. Kanske erbjuda alternativet att försöka igen.

Som du kan se i det föregående kodbiten har jag packat in det mesta av funktionaliteten i flera olika metoder. Den första är "CreateBillingPlan" som förklarades i föregående avsnitt. Den andra är "CreateBillingAgreement" som används för att prenumerera en användare på en plan:

offentlig statisk överenskommelse CreateBillingAgreement (strängplanId, ShippingAddress shippingAddress, strängnamn, strängbeskrivning, DateTime startDate) // PayPal Authentication tokens var apiContext = PayPalConfiguration.GetAPIContext (); var agreement = nytt avtal () namn = namn, beskrivning = beskrivning, start_date = startDate.ToString ("yyyy-MM-ddTHH: mm: ss") + "Z", betalare = ny betalare () payment_method = "paypal ", plan = ny Plan () id = planId, shipping_address = shippingAddress; var createdAgreement = agreement.Create (apiContext); returnera createdAgreement;

Den tredje metoden är "ExecuteBillingAgreement". Efter ett framgångsrikt prenumerationsgodkännande använder vi token som returneras för att aktivera prenumerationen:

statisk statisk tomgång ExecuteBillingAgreement (strängtoken) // PayPal Authentication tokens var apiContext = PayPalConfiguration.GetAPIContext (); var agreement = nytt avtal () token = token; var executedAgreement = agreement.Execute (apiContext);

Stäng en faktureringsavtal

Använd den här metoden för att avbryta ett avtal:

statisk statisk tomgång SuspendBillingAgreement (string agreementId) var apiContext = PayPalConfiguration.GetAPIContext (); var agreement = nytt avtal () id = agreementId; agreement.Suspend (apiContext, new AgreementStateDescriptor () note = "Avbrytande av avtalet");

Reaktivera en faktureringsavtal

Den här liknar verkligen den föregående:

statisk statisk tomgång ReactivateBillingAgreement (strängavtalId) var apiContext = PayPalConfiguration.GetAPIContext (); var agreement = nytt avtal () id = agreementId; agreement.ReActivate (apiContext, new AgreementStateDescriptor () note = "Återaktivera avtalet");

Avbryt en faktureringsöverenskommelse

Använd den här funktionen för att avbryta en plan:

offentlig statisk tomgång CancelBillingAgreement (string agreementId) var apiContext = PayPalConfiguration.GetAPIContext (); var agreement = nytt avtal () id = agreementId; agreement.Cancel (apiContext, new AgreementStateDescriptor () note = "Avbryta avtalet");

Uppdatera en faktureringsavtal

Det här alternativet är väldigt begränsat, och det jag förväntar mig av detta samtal är möjligheten att ändra prenumerationsplanen för att uppgradera eller nedgradera en kund. Detta stöds inte i ett enda samtal som det är i Stripe. Du måste hantera detta scenario genom att avbryta det aktuella avtalet och skapa en ny för uppgraderingar eller nedgraderingar. Det är inte idealiskt, men det kan förändras i framtiden.

Slutsats

Detta är en översikt över de vanligaste funktionerna som människor använder för att integrera med PayPal. Deras API är mycket större än de integrationsmetoder som förklaras i den här artikeln. Du kan också utfärda återbetalningar och delbetalningar, och de har många olika alternativ för kantfall i de prover som omfattas av denna artikel. Om du är intresserad av att få mer information om någon specifik integration, vänligen lämna ett förslag i kommentarerna.

Koda