Dalam tutorial ini, saya akan menunjukkan kepada anda cara membuat pembayaran menggunakan PayPal REST API dan C#. Semua perpustakaan yang mereka sediakan untuk bahasa yang berbeza seperti Ruby, Node.js, Python, PHP, dll. adalah sangat serupa, jadi semua konsep di sini boleh digunakan untuk semua perpustakaan.
Mula-mula, saya mencipta projek MVC dalam Visual Studio 2015: Fail > Baharu > Projek dan memilih Aplikasi ASP.NET.
Pilih templat ASP.NET 5 Aplikasi Web, yang menggunakan MVC 6 baharu. Ia serupa dengan MVC 5 jika anda sudah biasa dengannya.
Seperti yang anda lihat dalam foto di bawah, saya telah menambah beberapa fail dan folder pada penyelesaiannya. Dua perkara utama yang perlu diperhatikan ialah:
Gunakan NuGet untuk memasang SDK PayPal. Klik kanan pada nama penyelesaian dan pilih Urus Pakej NuGet, kemudian cari "PayPal" dan pasangkannya.
Untuk menyepadukan aplikasi kami dengan PayPal, kami perlu menavigasi ke Pembangun PayPal dan di bawah Aplikasi API REST, klik Buat Aplikasi.
Namakan apl anda dan pilih akaun pembangun kotak pasir untuk dikaitkan dengan apl itu. Untuk tujuan ujian, kami boleh menavigasi ke http://sandbox.paypal.com dan log masuk menggunakan butiran log masuk kotak pasir untuk melihat akaun PayPal ujian dan transaksi.
Selepas mengklik Buat Apl, kita akan melihat skrin pengesahan yang mengandungi ID pelanggan dan token rahsia.
Salin clientId dan token clientSecret ke appsettings.json seperti yang ditunjukkan dalam tangkapan skrin di bawah:
PayPal menyediakan persekitaran kotak pasir untuk ujian. Dari situ anda boleh membuat akaun pembeli dan penjual ujian. Selepas mendaftar, anda akan mempunyai akaun perusahaan dalam kotak pasir yang terikat dengan akaun pembangun anda.
Untuk membuat akaun ujian baharu, log masuk ke tapak web pembangun, kemudian klik pada tab Panel Kawalan dan navigasi ke Kotak Pasir > Akaun. Anda boleh melihat senarai akaun ujian (jika ada) di sini:
Jika anda masih belum membuat akaun ujian, teruskan dan klik Buat Akaun di penjuru kanan sebelah atas untuk membuat sekurang-kurangnya akaun peribadi ujian dan akaun perniagaan ujian.
Selepas mencipta akaun ujian anda, anda boleh log masuk melalui www.sandbox.paypal.com menggunakan alamat e-mel ujian dan kata laluan yang anda berikan kepada setiap akaun pada borang sebelumnya. Ini berguna untuk menguji sama ada dana akan dipindahkan ke Akaun Perniagaan Ujian anda apabila anda membuat pembelian menggunakan Akaun Ujian Peribadi anda. Kini anda sudah bersedia untuk mula menyepadukan dengan PayPal dan menguji sama ada dana dipindahkan dari satu akaun ke akaun yang lain.
PayPal menawarkan kaedah pembayaran yang berbeza. Anda boleh menggunakan pembayaran kad kredit terus, yang bermaksud pelanggan anda tidak dapat melihat halaman log masuk atau ringkasan PayPal - semuanya berlaku di tapak web anda. Untuk melakukan ini, anda perlu mematuhi PCI dan saya mengesyorkan menggunakan Stripe kerana anda hanya memerlukan SSL menggunakan perpustakaan JavaScript mereka. Untuk membayar melalui PayPal, sebaliknya, terdapat tiga langkah:
Dalam folder Services projek MVC saya, saya mencipta kelas PayPalPaymentService dan menambahkan kaedah berikut di dalamnya:
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;
}
Sesetengah parameter diluluskan dalam panggilan ini:
Fungsi sebelumnya boleh digunakan dari pengawal seperti yang ditunjukkan di bawah:
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();
}
Seperti yang anda lihat, saya mencipta tiga tindakan:
Senario ini hampir sama dengan kes sebelum ini. Anda mungkin mahu menggunakan kaedah ini jika anda cuba membuat prapesanan produk yang belum tersedia. Langkah-langkah untuk mendapatkan bayaran ini ialah:
Untuk melaksanakan jenis pembayaran ini, saya baru sahaja menambah kaedah baharu dalam kelas PayPalPaymentService untuk menangkap pembayaran:
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;
}
Kemudian saya menambah dua tindakan baharu dalam HomeController untuk memaparkan jenis pembayaran ini:
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();
}
Dalam contoh kod ini, saya telah mengekodkan nilai pembolehubah pembayaran untuk kesederhanaan. Dalam aplikasi sebenar anda, anda mungkin akan membungkusnya dalam kaedah yang mengambil semua nilai ini sebagai pembolehubah supaya semuanya boleh ditetapkan dan digunakan semula secara dinamik.
Ini dipanggil "Pelan Pengebilan" dalam PayPal - anda boleh membuat pelan pembayaran berulang dan melanggan pelanggan anda kepada pelan pengebilan dengan membuat Perjanjian Pengebilan. Menggunakan PayPal REST API, anda boleh membuat, mengemas kini atau memadam pelan pengebilan ini adalah sesuatu yang mungkin anda gunakan jika anda ingin membina panel pentadbir untuk mengurus perkara ini untuk perniagaan anda.
Langkah-langkah untuk membuat caj berulang kepada pelanggan adalah seperti berikut:
Buat rancangan pengebilan yang menentukan kitaran pengebilan. Ini adalah ringkasan parameter yang perlu kami luluskan semasa membuat rancangan.
这是一个代码片段，展示了如何创建计费计划：
// 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);
新创建的结算计划处于 CREATED 状态。将其激活为“活动”状态，以便您的客户可以订阅该计划。要激活该计划，我们需要发出 PATCH 请求：
// Activate the plan
var patchRequest = new PatchRequest()
{
new Patch()
{
op = "replace",
path = "/",
value = new Plan() { state = "ACTIVE" }
}
};
plan.Update(apiContext, patchRequest);
如您所见，PayPal 库是其 REST API 的直接包装器，这很好，但与 Stripe 等其他 API 相比，该 API 也非常复杂。因此，将所有 PayPal 通信包装在对象中，为我们的应用程序提供更清晰、更简单的 API，这确实是一个不错的选择。在这里您可以看到封装在多个带有参数的函数中的代码的样子：
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;
}
您可以通过提出“PATCH”请求来更新现有结算方案的信息。这是一个包装该调用的函数：
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);
}
要更新计费计划描述，我们可以调用此函数并传递正确的参数：
UpdateBillingPlan(
planId: "P-5FY40070P6526045UHFWUVEI",
path: "/",
value: new Plan { description = "new description" });
理想情况下，当您不想接受新客户加入结算计划时，您需要将其更新为“非活动”状态。这不会影响该计划的现有计费协议。只需调用 UpdateBillingPlan 函数即可完成此操作：
UpdateBillingPlan(
planId: "P-5FY40070P6526045UHFWUVEI",
path: "/",
value: new Plan { state = "INACTIVE" });
创建一个或多个结算计划后，您希望开始让客户注册您的订阅计划。为此，您需要收集客户详细信息并向 PayPal 提出请求。为了能够测试此功能，我向 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");
}
正如您在前面的代码片段中看到的，我已将大部分功能包装在几个方法中。第一个是上一节中解释的“CreateBillingPlan”。第二个是“CreateBillingAgreement”，用于为用户订阅计划：
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;
}
第三种方法是“ExecuteBillingAgreement”。成功订阅批准后，我们使用返回的令牌来激活订阅：
public static void ExecuteBillingAgreement(string token)
{
// PayPal Authentication tokens
var apiContext = PayPalConfiguration.GetAPIContext();
var agreement = new Agreement() { token = token };
var executedAgreement = agreement.Execute(apiContext);
}
使用此方法暂停协议：
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" });
}
这个与上一个非常相似：
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" });
}
使用此功能取消计划：
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" });
}
这个选项非常有限，我希望从这次通话中可以更改订阅计划，以升级或降级客户。与 Stripe 不同，单次调用不支持此功能。您需要通过取消当前协议并创建新的升级或降级协议来处理这种情况。这并不理想，但将来可能会改变。
这是人们用来与 PayPal 集成的最常用功能的概述。他们的 API 比本文中解释的集成方法要大得多 - 您还可以发放退款和部分退款，并且他们针对本文涵盖的示例中的边缘情况提供了许多不同的选项。如果您有兴趣获得有关任何特定集成的更多详细信息，请在评论中留下建议。
Atas ialah kandungan terperinci Deep Dive: Integrasi PayPal Bahagian 2: PayPal REST API. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
