使用C＃和ASP.NET Core的PayPal智能按钮的客户端/服务器实现

services.AddMvc()
        .AddNewtonsoftJson();

或者：

services.AddMvc()
        .AddNewtonsoftJson(options =>
                           options.SerializerSettings.ContractResolver =
                           new CamelCasePropertyNamesContractResolver());

using System;
using PayPalCheckoutSdk.Core;

using System.IO;
using System.Text;
using System.Runtime.Serialization.Json;

namespace PayPal
{
    public class PayPalClient
    {
        // Place these static properties into a settings area.
        public static string SandboxClientId { get; set; } = 
                             "{PayPal SANDBOX Client Id}";
        public static string SandboxClientSecret { get; set; } = 
                             "{PayPal SANDBOX Client Secret}";

        public static string LiveClientId { get; set; } = 
                      "{PayPal LIVE Client Id}";
        public static string LiveClientSecret { get; set; } = 
                      "{PayPal LIVE Client Secret}";

        ///
        /// Set up PayPal environment with sandbox credentials.
        /// In production, use LiveEnvironment.
        ///
        public static PayPalEnvironment Environment()
        {
#if DEBUG
            // You may want to create a UAT (user exceptance tester) 
            // role and check for this:
            // "if(_unitOfWork.IsUATTester(GetUserId())" instead of fcomiler directives.
            return new SandboxEnvironment(SandboxClientId,
                                          SandboxClientSecret);
#else
            return new LiveEnvironment(LiveClientId, 
                                       LiveClientSecret);
#endif
        }

        ///
        /// Returns PayPalHttpClient instance to invoke PayPal APIs.
        ///
        public static PayPalCheckoutSdk.Core.PayPalHttpClient Client()
        {
            return new PayPalHttpClient(Environment());
        }

        public static PayPalCheckoutSdk.Core.PayPalHttpClient Client(string refreshToken)
        {
            return new PayPalHttpClient(Environment(), refreshToken);
        }
        
        ///
        /// Use this method to serialize Object to a JSON string.
        ///
        public static String ObjectToJSONString(Object serializableObject)
        {
            MemoryStream memoryStream = new MemoryStream();
            var writer = JsonReaderWriterFactory.CreateJsonWriter(memoryStream,
                                                                  Encoding.UTF8,
                                                                  true,
                                                                  true,
                                                                  "  ");

            var ser = new DataContractJsonSerializer(serializableObject.GetType(),
                                                 new DataContractJsonSerializerSettings 
                                                     {
                                                         UseSimpleDictionaryFormat = true 
                                                     });

            ser.WriteObject(writer,
                            serializableObject);

            memoryStream.Position = 0;
            StreamReader sr = new StreamReader(memoryStream);

            return sr.ReadToEnd();
        }
    }
}

using System.Net;
using System.Net.Http.Headers;

namespace PayPal
{
    public class SmartButtonHttpResponse
    {
        readonly PayPalCheckoutSdk.Orders.Order _result;
        public SmartButtonHttpResponse(PayPalHttp.HttpResponse httpResponse)
        {
            Headers = httpResponse.Headers;
            StatusCode = httpResponse.StatusCode;
            _result = httpResponse.Result();
        }

        public HttpHeaders Headers { get; }
        public HttpStatusCode StatusCode { get; }

        public PayPalCheckoutSdk.Orders.Order Result()
        {
            return _result;
        }

        public string orderID { get; set; }
    }
}

using PayPalCheckoutSdk.Orders;
using System.Collections.Generic;

namespace PayPal
{
    public static class OrderBuilder
    {
        /// 
        /// Use classes from the PayPalCheckoutSdk to build an OrderRequest
        /// 
        /// 
        public static OrderRequest Build()
        {
            OrderRequest orderRequest = new OrderRequest();
            
            // Add code to fill out the order request properties
            // See the attached source code for a more detailed example. 

            return orderRequest;
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;

using PayPalCheckoutSdk.Orders;

namespace Test.Controllers
{
    public class CheckoutController : Controller
    {
        /// 
        /// Action to display the cart form for the SERVER side integration
        /// 
        /// 
        public IActionResult Index()
        {
#if DEBUG
            // You may want to create a UAT (user exceptance tester) role 
            // and check for this:
            // "if(_unitOfWork.IsUATTester(GetUserId())"
            // Company SANDBOX Client Id. To go live replace this with the live ID.
            ViewBag.ClientId = 
            PayPal.PayPalClient.SandboxClientId; // Get from a 
                                                       // data store or stettings
#else
            // Company LIVE Client Id. To go live replace this with the live ID.
            ViewBag.ClientId = 
            PayPal.PayPalClient.LiveClientId; // Get from a 
                                                       // data store or stettings
#endif

            ViewBag.CurrencyCode = "GBP"; // Get from a data store
            ViewBag.CurrencySign = "£";   // Get from a data store

            return View();
        }

        /// 
        /// This action is called when the user clicks on the PayPal button.
        /// 
        /// 
        [Route("api/paypal/checkout/order/create")]
        public async Task Create()
        {
            var request = new PayPalCheckoutSdk.Orders.OrdersCreateRequest();

            request.Prefer("return=representation");
            request.RequestBody(PayPal.OrderBuilder.Build());
            
            // Call PayPal to set up a transaction
            var response = await PayPal.PayPalClient.Client().Execute(request);
            
            // Create a response, with an order id.
            var result = response.Result();
            var payPalHttpResponse = new PayPal.SmartButtonHttpResponse(response)
            {
                orderID = result.Id
            };
            return payPalHttpResponse;
        }

        /// 
        /// This action is called once the PayPal transaction is approved
        /// 
        /// 
        /// 
        [Route("api/paypal/checkout/order/approved/{orderId}")]
        public IActionResult Approved(string orderId)
        {
            return Ok();
        }

        /// 
        /// This action is called once the PayPal transaction is complete
        /// 
        /// 
        /// 
        [Route("api/paypal/checkout/order/complete/{orderId}")]
        public IActionResult Complete(string orderId)
        {
            // 1. Update the database.
            // 2. Complete the order process. Create and send invoices etc.
            // 3. Complete the shipping process.
            return Ok();
        }

        /// 
        /// This action is called once the PayPal transaction is complete
        /// 
        /// 
        /// 
        [Route("api/paypal/checkout/order/cancel/{orderId}")]
        public IActionResult Cancel(string orderId)
        {
            // 1. Remove the orderId from the database.
            return Ok();
        }

        /// 
        /// This action is called once the PayPal transaction is complete
        /// 
        /// 
        /// 
        [Route("api/paypal/checkout/order/error/{orderId}/{error}")]
        public IActionResult Error(string orderId,
                                   string error)
        {
            // Log the error.
            // Notify the user.
            return NoContent();
        }
    }
}

    // This is stored just in case the user cancels the other 
    // or there is an error in the other process.
    var orderId;
    // Render the PayPal smart button into #paypal-button-container
    paypal.Buttons({

        // Set up the transaction
        createOrder: function (data, actions) {
            orderId = data.orderID;
            return fetch('/api/paypal/checkout/order/create/', {
                method: 'post'
            }).then(function (res) {
                return res.json();
            }).then(function (data) {
                return data.orderID;
            });
        },

        // Finalise the transaction
        onApprove: function (data, actions) {
            return fetch('/api/paypal/checkout/order/approved/' + data.orderID, {
                method: 'post'
            }).then(function (res) {
                return actions.order.capture();
            }).then(function (details) {

                // (Preferred) Notify the server that the transaction id complete 
                // and have an option to display an order completed screen.
                window.location.replace('/api/paypal/checkout/order/complete/' + 
                                         data.orderID + '/@ViewBag.CurrencyCode');
                
                // OR
                // Notify the server that the transaction id complete
                //httpGet('/api/paypal/checkout/order/complete/' + data.orderID);

                // Show a success message to the buyer
                alert('Transaction completed by ' + details.payer.name.given_name + '!');
            });
        },

        // Buyer cancelled the payment
        onCancel: function (data, actions) {
            httpGet('/api/paypal/checkout/order/cancel/' + data.orderID);
        },

        // An error occurred during the transaction
        onError: function (err) {
            httpGet('/api/paypal/checkout/order/error/' + orderId + '/' + 
                     encodeURIComponent(err));
        }

    }).render('#paypal-button-container');

除了URL，此代码对于所有解决方案都是相同的。

function httpGet(url) {
    var xmlHttp = new XMLHttpRequest();
    xmlHttp.open("GET", url, false);
    xmlHttp.send(null);
    return xmlHttp.responseText;
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace PayPal.Values
{
    /// 
    /// The intent to either capture payment immediately or
    /// authorize a payment for an order after order creation.
    /// 
    public static class CheckoutPaymentIntent
    {
        /// 
        /// The merchant intends to capture payment immediately after 
        /// the customer makes a payment.
        /// 
        public static string CAPTURE { get; private set; } = "CAPTURE";

        /// 
        /// The merchant intends to authorize a payment and
        /// place funds on hold after the customer makes a payment.
        /// Authorized payments are guaranteed for up to three days but
        /// are available to capture for up to 29 days.
        /// After the three-day honor period, the original authorized payment expires
        /// and you must re-authorize the payment.
        /// You must make a separate request to capture payments on demand.
        /// This intent is not supported when you have more than one `purchase_unit` 
        /// within your order.
        /// 
        public static string AUTHORIZE { get; private set; } = "AUTHORIZE";
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace PayPal.Values
{
    public static class CurrencyCode
    {
        /// 
        /// Great British Pounds
        /// 
        public static string GBP { get; private set; } = "GBP";

        /// 
        /// US Dolars
        /// 
        public static string USD { get; private set; } = "USD";

        /// 
        /// Euros
        /// 
        public static string EUR { get; private set; } = "EUR";
    }
}

根据需要添加其他货币。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace PayPal.Values
{
    /// 
    /// The type of landing page to show on the PayPal site for customer checkout.
    /// Default: NO_PREFERENCE.
    /// Source: https://developer.paypal.com/docs/api/orders/v2/
    /// 
    public class LandingPage
    {
        /// 
        /// When the customer clicks PayPal Checkout, 
        /// the customer is redirected to a page to log in to PayPal 
        /// and approve the payment.
        /// 
        public static string LOGIN { get; private set; } = "LOGIN";

        /// 
        /// When the customer clicks PayPal Checkout, 
        /// the customer is redirected to a page to enter credit or 
        /// debit card and other relevant billing information required to 
        /// complete the purchase.
        /// 
        public static string BILLING { get; private set; } = "BILLING";

        /// 
        /// When the customer clicks PayPal Checkout,
        /// the customer is redirected to either a page to log in to PayPal and
        /// approve the payment or to a page to enter credit or
        /// debit card and other relevant billing information
        /// required to complete the purchase, depending on their 
        /// previous interaction with PayPal.
        /// 
        public static string NO_PREFERENCE { get; private set; } = "NO_PREFERENCE";
    }
}

namespace PayPal.Values
{
    /// 
    /// The shipping preference:
    ///
    /// * Displays the shipping address to the customer.
    /// * Enables the customer to choose an address on the PayPal site.
    /// * Restricts the customer from changing the address 
    ///   during the payment-approval process.
    ///
    /// Default: GET_FROM_FILE.
    /// Source: https://developer.paypal.com/docs/api/orders/v2/
    /// 
    public static class ShippingPreference
    {
        /// 
        /// Use the customer-provided shipping address on the PayPal site.
        /// 
        public static string GET_FROM_FILE { get; private set; } = "GET_FROM_FILE";

        /// 
        /// Redact the shipping address from the PayPal site. 
        /// Recommended for digital goods.
        /// 
        public static string NO_SHIPPING { get; private set; } = "NO_SHIPPING";

        /// 
        /// Use the merchant-provided address. 
        /// The customer cannot change this address on the PayPal site.
        /// 
        public static string SET_PROVIDED_ADDRESS { get; private set; } = 
                                                         "SET_PROVIDED_ADDRESS";
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace PayPal.Values
{
    /// 
    /// Configures a Continue or Pay Now checkout flow.
    /// Source: https://developer.paypal.com/docs/api/orders/v2/
    /// 
    public static class UserAction
    {
        /// 
        /// After you redirect the customer to the PayPal payment page,
        /// a Continue button appears. Use this option when the final amount is not known
        /// when the checkout flow is initiated and you want to redirect
        /// the customer to the merchant page without processing the payment.
        /// 
        public static string CONTINUE { get; private set; } = "CONTINUE";

        /// 
        /// After you redirect the customer to the PayPal payment page,
        /// a Pay Now button appears.
        /// Use this option when the final amount is known when the checkout is initiated
        /// and you want to process the payment immediately 
        /// when the customer clicks Pay Now.
        /// 
        public static string PAY_NOW { get; private set; } = "PAY_NOW";
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace PayPal.Values.Item
{
    /// 
    /// The item category type.
    /// 
    public static class Category
    {
        /// 
        /// Goods that are stored, delivered, and
        /// used in their electronic format.
        /// This value is not currently supported for API callers that leverage the
        /// [PayPal for Commerce Platform]
        /// (https://www.paypal.com/us/webapps/mpp/commerce-platform) product.
        /// 
        public static string DIGITAL_GOODS { get; private set; } = "DIGITAL_GOODS";

        /// 
        /// A tangible item that can be shipped with proof of delivery.
        /// 
        public static string PHYSICAL_GOODS { get; private set; } = "PHYSICAL_GOODS";
    }
}