Início / coding / Perguntas / 79561927
Accepted
Alex
Asked: 2025-04-08 19:47:45 +0800 CST

Desabilitar a opção "Enviar para endereço de cobrança" do PayPal

  • 772

Nosso aplicativo ASP.NET vende apenas produtos digitais e não precisa da caixa de seleção "Enviar para endereço de cobrança". Usando o exemplo de código da documentação do PayPal Checkout , obtive a seguinte index.htmlpágina:

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>PayPal JS SDK Standard Integration</title>
</head>
<body>
    <div id="paypal-button-container"></div>
    <p id="result-message"></p>

    <!-- Initialize the JS-SDK -->
    <script src="https://www.paypal.com/sdk/js?client-id=<my_client_id>&buyer-country=US&currency=USD&components=buttons&enable-funding=card&commit=false&disable-funding=paylater&debug=true"
            data-sdk-integration-source="developer-studio"></script>
    <script src="Scripts/paypal/app.js"></script>
</body>
</html>

O código app.jsé:

const paypalButtons = window.paypal.Buttons({
    style: {
        shape: "rect",
        layout: "vertical",
        color: "gold",
        label: "paypal",
    },
    message: {
        amount: 100,
    },
    
    async createOrder() {
        try {
            const response = await fetch("/api/paypal/orders", {
                method: "POST",
                headers: {
                    "Content-Type": "application/json",
                },
                // use the "body" param to optionally pass additional order information
                // like product ids and quantities
                body: JSON.stringify({
                    cart: [
                        {
                            id: "YOUR_PRODUCT_ID",
                            quantity: "YOUR_PRODUCT_QUANTITY",
                        },
                    ]
                })
            });

            const orderData = await response.json();

            if (orderData.id) {
                return orderData.id;
            }
            const errorDetail = orderData?.details?.[0];
            const errorMessage = errorDetail
                ? `${errorDetail.issue} ${errorDetail.description} (${orderData.debug_id})`
                : JSON.stringify(orderData);

            throw new Error(errorMessage);
        } catch (error) {
            console.error(error);
            // resultMessage(`Could not initiate PayPal Checkout...<br><br>${error}`);
        }
    },
    async onApprove(data, actions) {
        try {
            const response = await fetch(
                `/api/paypal/orders/${data.orderID}/capture`,
                {
                    method: "POST",
                    headers: {
                        "Content-Type": "application/json",
                    },
                }
            );

            const orderData = await response.json();
            // Three cases to handle:
            //   (1) Recoverable INSTRUMENT_DECLINED -> call actions.restart()
            //   (2) Other non-recoverable errors -> Show a failure message
            //   (3) Successful transaction -> Show confirmation or thank you message

            const errorDetail = orderData?.details?.[0];

            if (errorDetail?.issue === "INSTRUMENT_DECLINED") {
                // (1) Recoverable INSTRUMENT_DECLINED -> call actions.restart()
                // recoverable state, per
                // https://developer.paypal.com/docs/checkout/standard/customize/handle-funding-failures/
                return actions.restart();
            } else if (errorDetail) {
                // (2) Other non-recoverable errors -> Show a failure message
                throw new Error(
                    `${errorDetail.description} (${orderData.debug_id})`
                );
            } else if (!orderData.purchase_units) {
                throw new Error(JSON.stringify(orderData));
            } else {
                // (3) Successful transaction -> Show confirmation or thank you message
                // Or go to another URL:  actions.redirect('thank_you.html');
                const transaction =
                    orderData?.purchase_units?.[0]?.payments?.captures?.[0] ||
                    orderData?.purchase_units?.[0]?.payments
                        ?.authorizations?.[0];
                resultMessage(
                    `Transaction ${transaction.status}: ${transaction.id}<br>
          <br>See console for all available details`
                );
                console.log(
                    "Capture result",
                    orderData,
                    JSON.stringify(orderData, null, 2)
                );
            }
        } catch (error) {
            console.error(error);
            resultMessage(
                `Sorry, your transaction could not be processed...<br><br>${error}`
            );
        }
    }
});
paypalButtons.render("#paypal-button-container");

// Example function to show a result to the user. Your site's UI library can be used instead.
function resultMessage(message) {
    const container = document.querySelector("#result-message");
    container.innerHTML = message;
}

O código acima precisa incluir o seguinte para desabilitar a opção de envio, mas onde adicioná-lo?

application_context: {
    shipping_preference: "NO_SHIPPING"
}

Esta questão , application_contextmas observe que não há nenhum lugar para colocar o ponto de extremidade da API do servidor, como fetchno meu código acima.

Agradecemos sua ajuda.

Atualização: Tentei adicionar o application_contextao bodyparâmetro e não teve efeito:

body: JSON.stringify({
    cart: [
        {
            id: "YOUR_PRODUCT_ID",
            quantity: "YOUR_PRODUCT_QUANTITY",
        },
    ],
    application_context: {
        shipping_preference: "NO_SHIPPING"
    }
})

insira a descrição da imagem aqui

Atualização 2: Aqui está o código C# relevante (.NET 4.8). Observe o " PaymentSourcemas o que você adiciona a ele?".

[System.Web.Http.Route("orders")]
[System.Web.Http.HttpPost]
public async Task<IHttpActionResult> CreateOrderAsync([FromBody] dynamic cart)
{
    try
    {
        var result = await _CreateOrderAsync(cart);
        return Json(result.Data);
    }
    catch (Exception ex)
    {
        Console.Error.WriteLine("Failed to create order:", ex);
        return GetInternalServerError("Failed to create order.");
    }
}

private async Task<dynamic> _CreateOrderAsync(dynamic cart)
{
    var createOrderInput = new CreateOrderInput
    {
        Body = new OrderRequest
        {
            Intent = _paymentIntentMap["CAPTURE"],
            PaymentSource = new PaymentSource
            {
                // What goes here?
            },
            PurchaseUnits = new List<PurchaseUnitRequest>
            {
                new PurchaseUnitRequest
                {
                    Amount = new AmountWithBreakdown
                    {
                        CurrencyCode = "USD",
                        MValue = "100",
                        Breakdown = new AmountBreakdown
                        {
                            ItemTotal = new Money
                            {
                                CurrencyCode = "USD",
                                MValue = "100",
                            }
                        }
                    },
                    // lookup item details in `cart` from database
                    Items = new List<Item>
                    {
                        new Item
                        {
                            Name = "T-Shirt",
                            UnitAmount = new Money
                            {
                                CurrencyCode = "USD",
                                MValue = "100",
                            },
                            Quantity = "1",
                            Description = "Super Fresh Shirt",
                            Sku = "sku01",
                            Category = ItemCategory.DigitalGoods,
                        },
                    }
                }
            }
        }
    };

    ApiResponse<Order> result = await _ordersController.CreateOrderAsync(createOrderInput);
    return result;
}

protected IHttpActionResult GetInternalServerError(string content)
{
    var message = new HttpResponseMessage(HttpStatusCode.InternalServerError)
    {
        Content = new StringContent(content)
    };
    return new ResponseMessageResult(message);
}

Atualização 3: Corrigimos os links da postagem. Peço desculpas pelo erro anterior.

Solução: Aqui está o código na _CreateOrderAsync()ação do controlador que corrigiu o problema, graças a @PrestonPHX:

PaymentSource = new PaymentSource
{
    Paypal = new PaypalWallet
    {
        ExperienceContext = new PaypalWalletExperienceContext
        {
            ShippingPreference = PaypalWalletContextShippingPreference.NoShipping
        }
    }
},
javascript

1 respostas

  1. Best Answer

    1. application_context está obsoleto. Use payment_source.paypal

    2. O local para adicioná-lo não é no seu código front-end, nem no "corpo" que o código front-end envia para o seu back-end em "/api/paypal/orders" (ou qualquer caminho local que você use). Em vez disso, o local para adicioná-lo é dentro dessa rota do lado do servidor, quando ele se comunica com a API de Pedidos do PayPal para criar o pedido. Você não incluiu esse código na sua pergunta, portanto, não podemos fornecer mais informações.

    Edição: conforme os comentários, https://developer.paypal.com/serversdk/net-standard-library/api-endpoints/orders/create-order está sendo usado, e toda a documentação sobre o que pode ser definido está lá. Algo assim deve funcionar (não testado).

            var orderRequest = new OrderRequest
        {
            Intent = OrderRequest.IntentType.CAPTURE,
            PurchaseUnits = new List<PurchaseUnit>
            {
                new PurchaseUnit
                {
                    Amount = new Amount
                    {
                        CurrencyCode = "USD",
                        Value = "100.00"
                    }
                }
            },
            PaymentSource = new PaymentSource
            {
                Paypal = new PaypalWallet
                {
                    ExperienceContext = new PaypalWalletExperienceContext
                    {
                        ShippingPreference = ExperienceContext.ShippingPreferenceType.NO_SHIPPING
                    }
                }
            }
        };
    • 2

relate perguntas