public async Task <PaymentResult> CapturePayment(string orderId)
{
var token = await database.TokenRepository.GetTokenByCodeAndType(orderId, TokenType.Payment,
httpContextReader.CurrentUserId)
?? throw new EntityNotFoundException("Token not found");
if (token.DateCreated < DateTime.Now.AddHours(-Constants.PaymentTokenExpireTimeInHours))
{
throw new TokenExpiredException();
}
var orderCaptureRequest = new OrdersCaptureRequest(orderId)
.RequestBody(new OrderActionRequest());
var orderTransaction = await database.OrderTransactionRepository.FindByColumn(
new("transaction_id", orderId)) ?? throw new DatabaseException();
orderTransaction.Validate();
if (!await database.OrderTransactionRepository.Update(orderTransaction))
{
throw new DatabaseException();
}
var response = await paypalClient.Execute(orderCaptureRequest)
?? throw new PaymentException(ErrorMessages.PaypalErrorMessage);
return(new PaymentResult
{
OrderId = response.Result <Order>().Id,
StatusCode = response.StatusCode
});
}
public async Task <OrderConfirmationViewModel> ConfirmOrder(string token)
{
var options = paypalOptions.CurrentValue;
PayPalEnvironment environment = CreateEnvironment();
var client = new PayPalHttpClient(environment);
var request = new OrdersCaptureRequest(token);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
try
{
var response = await client.Execute(request);
Order order = response.Result <Order>();
return(OrderConfirmationViewModel.FromOrder(order));
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
logger.LogError($"Il tentativo di catturare il pagamento è fallito con status code {statusCode} e debugId {debugId}");
throw new PaymentException();
}
}
public async Task <Guid> ConfirmOrder(string token)
{
PayPalEnvironment environment = CreateEnvironment();
var client = new PayPalHttpClient(environment);
var request = new OrdersCaptureRequest(token);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
try
{
HttpResponse response = await client.Execute(request);
PaypalOrder order = response.Result <PaypalOrder>();
Guid invoiceId = Guid.Parse(order.PurchaseUnits.First().CustomId);
return(invoiceId);
//_eventBus.Trigger(new InvoicePaymentProviderPayedEventData(invoiceId));
}
catch (HttpException httpException)
{
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
throw httpException;
}
}
/*
* Method to capture order after creation. Valid approved order Id should be
* passed an argument to this method.
*/
public async static Task <HttpResponse> CaptureOrder(string OrderId, bool debug = false)
{
var request = new OrdersCaptureRequest(OrderId);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
var response = await PayPalClient.client().Execute(request);
if (debug)
{
var result = response.Result <Order>();
Console.WriteLine("Status: {0}", result.Status);
Console.WriteLine("Order Id: {0}", result.Id);
Console.WriteLine("Intent: {0}", result.Intent);
Console.WriteLine("Links:");
foreach (LinkDescription link in result.Links)
{
Console.WriteLine("\t{0}: {1}\tCall Type: {2}", link.Rel, link.Href, link.Method);
}
Console.WriteLine("Capture Ids: ");
foreach (PurchaseUnit purchaseUnit in result.PurchaseUnits)
{
foreach (Capture capture in purchaseUnit.Payments.Captures)
{
Console.WriteLine("\t {0}", capture.Id);
}
}
AmountWithBreakdown amount = result.PurchaseUnits[0].Amount;
Console.WriteLine("Buyer:");
Console.WriteLine("\tEmail Address: {0}\n\tName: {1}\n\tPhone Number: {2}{3}", result.Payer.EmailAddress, result.Payer.Name.FullName, result.Payer.Phone.CountryCode, result.Payer.Phone.NationalNumber);
Console.WriteLine("Response JSON: \n {0}", PayPalClient.ObjectToJSONString(result));
}
return(response);
}
public async Task <ActionResult> ApproveOrder(string orderId)
{
if (string.IsNullOrEmpty(orderId))
{
return(BadRequest());
}
try
{
var request = new OrdersCaptureRequest(orderId);
// in order for mock responses to work, the payer test account must be enabled in the dashboard.
// https://developer.paypal.com/docs/api-basics/sandbox/error-conditions/#enable-negative-testing
// codes: https://developer.paypal.com/docs/api/orders/v2/#errors
// request.Headers.Add("PayPal-Mock-Response", "{\"mock_application_codes\": \"INTERNAL_SERVICE_ERROR\"}");
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
var response = await _httpClient.Execute(request);
var result = response.Result <Order>();
return(Ok(result));
}
catch (Exception ex)
{
_logger.LogError(ex, "PayPal Approve Order Exception");
return(Ok(ex.GetPayPalError()));
}
}
public async static Task <PayPalHttp.HttpResponse> CreatePaypalOrder(string OrderId, bool debug = false)
{
var request = new OrdersCaptureRequest(OrderId);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
//3. Call PayPal to capture an order
var response = await PayPalClient.client().Execute(request);
//4. Save the capture ID to your database. Implement logic to save capture to your database for future reference.
if (debug)
{
var result = response.Result <Order>();
Console.WriteLine("Status: {0}", result.Status);
Console.WriteLine("Order Id: {0}", result.Id);
Console.WriteLine("Intent: {0}", result.CheckoutPaymentIntent);
Console.WriteLine("Links:");
foreach (LinkDescription link in result.Links)
{
Console.WriteLine("\t{0}: {1}\tCall Type: {2}", link.Rel, link.Href, link.Method);
}
Console.WriteLine("Capture Ids: ");
foreach (PurchaseUnit purchaseUnit in result.PurchaseUnits)
{
foreach (Capture capture in purchaseUnit.Payments.Captures)
{
Console.WriteLine("\t {0}", capture.Id);
}
}
AmountWithBreakdown amount = result.PurchaseUnits[0].AmountWithBreakdown;
}
return(response);
}
//[Route("Payments/CaptureOrder")]
public async Task <HttpResponse> CaptureOrder([FromBody] dynamic OrderId, bool debug = true)
{
var oi = (string)OrderId["OrderId"];
var request = new OrdersCaptureRequest(oi);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
//3. Call PayPal to capture an order
var response = await PayPalClient.client().Execute(request);
var result = response.Result <Order>();
response.Headers.Add("Payee Name", result.Payer.Name.GivenName + " " + result.Payer.Name.Surname);
//4. Save the capture ID to your database. Implement logic to save capture to your database for future reference.
if (debug)
{
Debug.WriteLine("Status: {0}", result.Status);
Debug.WriteLine("Order Id: {0}", result.Id);
Debug.WriteLine("Intent: {0}", result.Intent);
Debug.WriteLine("Links:");
foreach (LinkDescription link in result.Links)
{
Debug.WriteLine("\t{0}: {1}\tCall Type: {2}", link.Rel, link.Href, link.Method);
}
Debug.WriteLine("Capture Ids: ");
foreach (PurchaseUnit purchaseUnit in result.PurchaseUnits)
{
foreach (Capture capture in purchaseUnit.Payments.Captures)
{
Debug.WriteLine("\t {0}", capture.Id);
}
}
AmountWithBreakdown amount = result.PurchaseUnits[0].Amount;
Debug.WriteLine("Buyer:");
Debug.WriteLine("\tEmail Address: {0}\n\tName: {1}\n\tPhone Number: {2}{3}", result.Payer.EmailAddress, result.Payer.Name.GivenName + " " + result.Payer.Name.Surname, result.Payer.Phone.CountryCode, result.Payer.Phone.NationalNumber);
}
Debug.WriteLine("************************************************************************************** ");
//Id of last inserted record in payments table
int last_payment_id = _context.Payments.Max(item => item.id);
Debug.WriteLine("Buyer:", last_payment_id);
Payments payments = await _context.Payments.SingleOrDefaultAsync(m => m.id == last_payment_id);
Debug.WriteLine("************************************************************************************** ");
payments.amount = result.PurchaseUnits[0].Amount.Value;
payments.transactionId = result.Id;
payments.payeeEmail = result.Payer.EmailAddress;
if (ModelState.IsValid)
{
_context.Update(payments);
await _context.SaveChangesAsync();
}
return(response);
}
public async static Task <HttpResponse> CaptureOrder(string OrderId, bool debug = false)
{
var request = new OrdersCaptureRequest(OrderId);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
var response = await PayPalClient.client().Execute(request);
return(response);
}
public async Task <bool> CaptureOrder(string token)
{
var request = new OrdersCaptureRequest(token);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
var response = await m_PayPalHttpClient.Execute(request);
var order2 = response.Result <PayPalCheckoutSdk.Orders.Order>();
return(order2.Status == "COMPLETED");
}
public async Task <Order> CaptureOrder(string OrderId, bool debug = true)
{
var request = new OrdersCaptureRequest(OrderId);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
//3. Call PayPal to capture an order
var response = await PayPalClientService.Client().Execute(request);
//4. Save the capture ID to your database. Implement logic to save capture to your database for future reference.
//if (debug)
//{
var result = response.Result <Order>();
Console.WriteLine("Status: {0}", result.Status);
Console.WriteLine("Order Id: {0}", result.Id);
Console.WriteLine("Intent: {0}", result.CheckoutPaymentIntent);
Console.WriteLine("Links:");
foreach (LinkDescription link in result.Links)
{
Console.WriteLine("\t{0}: {1}\tCall Type: {2}", link.Rel, link.Href, link.Method);
}
Console.WriteLine("Capture Ids: ");
foreach (PurchaseUnit purchaseUnit in result.PurchaseUnits)
{
foreach (Capture capture in purchaseUnit.Payments.Captures)
{
Console.WriteLine("\t {0}", capture.Id);
}
}
PayPalCheckoutSdk.Orders.AmountWithBreakdown amount = result.PurchaseUnits[0].AmountWithBreakdown;
Console.WriteLine("Buyer:");
Console.WriteLine("\tEmail Address: {0}\n\tName: {1}\n\tPhone Number: {2}", result.Payer.Email,
result.Payer.Name.GivenName + " " + result.Payer.Name.Surname, result.Payer.AddressPortable.CountryCode
);
//}
return(result);
//return Json(new
//{
// id = result.Id,
// CheckoutPaymentIntent = result.CheckoutPaymentIntent,
// CreateTime = result.CreateTime,
// Links = result.Links,
// Payer = result.Payer,
// PurchaseUnits = result.PurchaseUnits,
// Status = result.Status,
// UpdateTime = result.UpdateTime,
// GivenName = result.Payer.Name.GivenName,
// SurName = result.Payer.Name.Surname,
//});
}
public async static Task <HttpResponse> CaptureOrder(string OrderId)
{
var request = new OrdersCaptureRequest(OrderId);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
var response = await PayPalClient.client().Execute(request);
// Add code here to process the response results on server.
// for example, you can extract the order ID and buyer's information and store them to database.
return(response);
}
public async Task <PayPalDto> GetPaymentAsync(string orderId, CancellationToken token)
{
var captureRequest = new OrdersCaptureRequest(orderId);
captureRequest.RequestBody(new OrderActionRequest());
token.ThrowIfCancellationRequested();
var response3 = await _client.Execute(captureRequest);
var result = response3.Result <Order>();
var purchaseUnit = result.PurchaseUnits[0];
return(new PayPalDto(purchaseUnit.ReferenceId, decimal.Parse(purchaseUnit.Payments.Captures[0].Amount.Value)));
}
private async Task <Order> PaypalCapture(IDbConnection c, IDbTransaction t, string publicKey, string secretKey, string apiUrl, string orderId)
{
// Construct a request object and set desired parameters
// Replace ORDER-ID with the approved order id from create order
var request = new OrdersCaptureRequest(orderId);
request.RequestBody(new OrderActionRequest());
var response = await Paypal.client(publicKey, secretKey).Execute(request);
// var statusCode = response.StatusCode;
Order result = response.Result <Order>();
return(result);
}
public async Task <IActionResult> CaptureOrder(string orderId, bool debug = false)
{
string captureId = null;
var request = new OrdersCaptureRequest(orderId);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
//3. Call PayPal to capture an order
var response = await PayPalClient.client().Execute(request);
//4. Save the capture ID to your database. Implement logic to save capture to your database for future reference.
if (debug)
{
var output = response.Result <Order>();
Console.WriteLine("Status: {0}", output.Status);
Console.WriteLine("Order Id: {0}", output.Id);
Console.WriteLine("Intent: {0}", output.Intent);
Console.WriteLine("Links:");
foreach (LinkDescription link in output.Links)
{
Console.WriteLine("\t{0}: {1}\tCall Type: {2}", link.Rel, link.Href, link.Method);
}
Console.WriteLine("Capture Ids: ");
foreach (PurchaseUnit purchaseUnit in output.PurchaseUnits)
{
foreach (Capture capture in purchaseUnit.Payments.Captures)
{
captureId = capture.Id;
Console.WriteLine("\t {0}", capture.Id);
}
}
AmountWithBreakdown amount = output.PurchaseUnits[0].Amount;
Console.WriteLine("Buyer:");
Console.WriteLine("\tEmail Address: {0}\n\tName: {1}\n\tPhone Number: {2}{3}", output.Payer.EmailAddress, output.Payer.Name.FullName, output.Payer.Phone.CountryCode, output.Payer.Phone.NationalNumber);
}
var result = response.Result <Order>();
var r = new PayPalCapture();
r.OrderId = orderId;
foreach (PurchaseUnit purchaseUnit in result.PurchaseUnits)
{
foreach (Capture capture in purchaseUnit.Payments.Captures)
{
captureId = capture.Id;
}
}
r.CaptureId = captureId;
return(Ok(r));
}
// [HttpGet("paypal")]
// public async Task<HttpResponse> paypal() {
// HttpResponse response;
// var payer = new Payer()
// }
public async static Task <HttpResponse> captureOrder(string id)
{
var request = new OrdersCaptureRequest(id);
request.RequestBody(new OrderActionRequest());
HttpResponse response = await PayPalClient.client().Execute(request);
var statusCode = response.StatusCode;
Order result = response.Result <Order>();
Console.WriteLine("Status: {0}", result.Status);
Console.WriteLine("Capture Id: {0}", result.Id);
return(response);
}
public async Task <HttpResponse> CaptureOrder(string orderId)
{
// Construct a request object and set desired parameters
// Replace ORDER-ID with the approved order id from create order
var request = new OrdersCaptureRequest(orderId);
request.RequestBody(new OrderActionRequest());
HttpResponse response = await Client().Execute(request);
var statusCode = response.StatusCode;
Order result = response.Result <Order>();
return(response);
}
public async void TestOrdersCaptureRequest()
{
var orderResponse = await OrdersCreateTest.CreateOrder();
var orderId = orderResponse.Result <Order>().Id;
OrdersCaptureRequest request = new OrdersCaptureRequest(orderId);
request.RequestBody(new OrderActionRequest());
HttpResponse response = await TestHarness.client().Execute(request);
Assert.Equal(201, (int)response.StatusCode);
Assert.NotNull(response.Result <Order>());
}
public async Task <HttpResponse> GetTransaction(string OrderId, bool debug = false)
{
//string orderId = "8TH80554NC7396247";
string orderId = "23139793XR804084D";
try
{
//RefundsGetRequest
//CapturesGetRequest
var request = new OrdersCaptureRequest(orderId);
request.RequestBody(new OrderActionRequest());
PayPalEnvironment payPalEnvironment = new SandboxEnvironment("Af8jLh10kVlYkx4lunz6GSduOt92LyS_hRCOjzRZaU1SZrr1Eb7xYXBjLn-ue6SqiVlsTCEPPlMmL4bI", "EKQBNJEbuBx-yIx0vdtFTiptyfnnyjQVYwhPAmiuKe19T3Viko-B8E-wYrfQuvGdVCOJ97zH9-arreb4");
var response = await new PayPalHttpClient(payPalEnvironment).Execute(request);
var result = response.Result <Order>();
foreach (PurchaseUnit purchaseUnit in result.PurchaseUnits)
{
foreach (PayPalCheckoutSdk.Orders.Capture capture in purchaseUnit.Payments.Captures)
{
//captureId = capture.Id;
}
}
Console.WriteLine("Retrieved Order Status");
//result.Payer.A
Console.WriteLine("Status: {0}", result.Status);
Console.WriteLine("Order Id: {0}", result.Id);
//Console.WriteLine("Intent: {0}", result.CheckoutPaymentIntent);
Console.WriteLine("Links:");
//foreach (LinkDescription link in result.Links)
//{
// Console.WriteLine("\t{0}: {1}\tCall Type: {2}", link.Rel, link.Href, link.Method);
//}
// AmountWithBreakdown amount = result.PurchaseUnits[0].AmountWithBreakdown;
// Console.WriteLine("Total Amount: {0} {1}", amount.CurrencyCode, amount.Value);
// Console.WriteLine("Response JSON: \n {0}", PayPalClient.ObjectToJSONString(result));
return(response);
}
catch (Exception e)
{
OrdersGetRequest request = new OrdersGetRequest(orderId);
PayPalEnvironment payPalEnvironment = new SandboxEnvironment("Af8jLh10kVlYkx4lunz6GSduOt92LyS_hRCOjzRZaU1SZrr1Eb7xYXBjLn-ue6SqiVlsTCEPPlMmL4bI", "EKQBNJEbuBx-yIx0vdtFTiptyfnnyjQVYwhPAmiuKe19T3Viko-B8E-wYrfQuvGdVCOJ97zH9-arreb4");
return(await new PayPalHttpClient(payPalEnvironment).Execute(request));
}
}
public async static Task <HttpResponse> captureOrder()
{
// Construct a request object and set desired parameters
// Replace ORDER-ID with the approved order id from create order
var request = new OrdersCaptureRequest("APPROVED-ORDER-ID");
request.RequestBody(new OrderActionRequest());
HttpResponse response = await client().Execute(request);
var statusCode = response.StatusCode;
Order result = response.Result <Order>();
Console.WriteLine("Status: {0}", result.Status);
Console.WriteLine("Capture Id: {0}", result.Id);
return(response);
}
public async Task <HttpResponse> PayPalCaptureOrder(string OrderId, bool debug = false)
{
try
{
var request = new OrdersCaptureRequest(OrderId);
request.Prefer(PAYPAL_HEADER_RETURN);
request.RequestBody(new OrderActionRequest());
var response = await Client().Execute(request);
return(response);
}
catch
{
return(null);
}
}
public async Task <DataResponse <Order> > CapturePayPalPayment(string token, string payerId)
{
var response = new DataResponse <Order>()
{
Succeeded = false, Data = null
};
try
{
var request = new OrdersCaptureRequest(token);
request.RequestBody(new OrderActionRequest());
var httpResponse = await PayPalClient.Client(_configuration["PayPal:ClientId"], _configuration["PayPal:ClientSecret"]).Execute(request);
if (httpResponse.StatusCode == System.Net.HttpStatusCode.Created)
{
var order = httpResponse.Result <Order>();
var saved = _packageService.MarkSubscriptionAsPayed(order.Id);
if (saved)
{
response.Succeeded = true;
response.Data = order;
}
else
{
_logger.LogError($"PayPal Payment capture failure, Status: '{httpResponse.StatusCode}'");
response.ErrorMessage = "Update subscription payment statys failed";
}
}
else
{
_logger.LogError($"PayPal Payment capture failure, Status: '{httpResponse.StatusCode}'");
response.ErrorMessage = "PayPal payment couldn't be captured, please contact administrators!";
}
return(response);
}
catch (Exception ex)
{
_logger.LogError(ex, $"On capture paypal payment: Exception thrown with error {ex.Message}");
response.ErrorMessage = "Due to technical issues we are not able to capture the paypal payment";
}
return(response);
}
public async Task <string> CaptureOrderAsync(PayPalCaptureOrderRequestInput input)
{
var request = new OrdersCaptureRequest(input.OrderId);
request.RequestBody(new OrderActionRequest());
var response = await _client.Execute(request);
var payment = response.Result <Order>();
if (payment.Status != "COMPLETED")
{
throw new UserFriendlyException(L("PaymentFailed"));
}
return(payment.Id);
}
public async Task CapturePendingOrder(string orderId, string payerId)
{
Order order;
{
var client = _payPalClientProvider.BuildHttpClient();
var request = new OrdersCaptureRequest(orderId);
request.RequestBody(new OrderActionRequest());
var response = await client.Execute(request);
if (response.StatusCode != HttpStatusCode.Created)
{
_logger.LogError("Invalid status code from PayPal order capture: status: {Status} response: {Response}", response.StatusCode, SerializePayPalType(response.Result <object>()));
throw new Exception("Invalid PayPal response");
}
order = response.Result <Order>();
if (order.Status != "COMPLETED")
{
_logger.LogError("The order from PayPal wasn't marked as COMPELTED: {Response}", SerializePayPalType(response.Result <object>()));
throw new Exception("The order from PayPal wasn't marked as COMPELTED");
}
}
using (var con = new ConScope(_dataService))
using (var trans = await con.BeginTransaction())
{
var pendingOrder = con.Connection.Single <PayPalOrder>(x => x.PayPalOrderId == orderId);
if (pendingOrder.OrderStatus == PayPalOrderStatus.Completed)
{
throw new Exception($"Attempted to update order {orderId} as completed, but it is already marked as completed.");
}
pendingOrder.OrderStatus = PayPalOrderStatus.Completed;
pendingOrder.PayPalPayerId = payerId;
pendingOrder.PayPalOrderJson = SerializePayPalType(order);
await con.Connection.SaveAsync(pendingOrder);
await _transactionsService.AddTransaction(pendingOrder.AccountId, pendingOrder.Amount, "PayPal reload", pendingOrder.PayPalOrderJson, pendingOrder.Id);
trans.Commit();
}
}
CompletePayment(HttpResponse response)
{
OrdersCaptureRequest request =
new OrdersCaptureRequest(
response.Result <Order>().Id);
request.RequestUri = new Uri(response
.Result <Order>().Links[3].Href);
request.RequestBody(new OrderActionRequest());
request.ContentType = "application/json";
request.Prefer("return=representation");
HttpResponse captureResponse = await Client()
.Execute(request);
return(captureResponse);
}
public static HttpResponse captureOrder(string id)
{
// Construct a request object and set desired parameters
// Replace ORDER-ID with the approved order id from create order
string[] splitUrl = id.Split('/');
if (splitUrl.Length > 0)
{
var request = new OrdersCaptureRequest(splitUrl[6]);
request.RequestBody(new OrderActionRequest());
HttpResponse response = client().Execute(request).Result;
var statusCode = response.StatusCode;
Order result = response.Result <Order>();
return(response);
}
else
{
return(null);
}
}
internal async Task <bool> CapturePaypalPayment(string paypalId)
{
Payment = new Payment()
{
PaymentProvider = "PayPal",
Reference = paypalId,
};
var request = new OrdersCaptureRequest(paypalId);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
var response = await PayPalClient.client().Execute(request);
var paypalOrder = response.Result <PayPalCheckoutSdk.Orders.Order>();
if (!paypalOrder.Status.Equals("COMPLETED"))
{
return(false);
}
Status = OrderStatusType.InProgress;
Payment.Reference = paypalOrder.PurchaseUnits.FirstOrDefault().Payments.Captures.FirstOrDefault().Id;
Payment.DateTime = DateTime.Parse(paypalOrder.UpdateTime);
Payment.Type = PaymentType.Complete;
Payment.Email = paypalOrder.Payer.Email;
var purchaseUnit = paypalOrder.PurchaseUnits.FirstOrDefault();
Name = purchaseUnit.ShippingDetail.Name.FullName;
FirstLine = purchaseUnit.ShippingDetail.AddressPortable.AddressLine1;
SecondLine = purchaseUnit.ShippingDetail.AddressPortable.AddressLine2;
if (purchaseUnit.ShippingDetail.AddressPortable.AdminArea1 != null)
{
City = purchaseUnit.ShippingDetail.AddressPortable.AdminArea1;
}
if (purchaseUnit.ShippingDetail.AddressPortable.AdminArea2 != null)
{
City = purchaseUnit.ShippingDetail.AddressPortable.AdminArea2;
}
Postcode = purchaseUnit.ShippingDetail.AddressPortable.PostalCode;
return(true);
}
private async Task <Order> CaptureOrder(string OrderId, bool debug = false)
{
var request = new OrdersCaptureRequest(OrderId);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
var response = await _client.Execute(request);
var result = response.Result <Order>();
if (debug)
{
Console.WriteLine("Status: {0}", result.Status);
Console.WriteLine("Order Id: {0}", result.Id);
Console.WriteLine("Intent: {0}", result.CheckoutPaymentIntent);
Console.WriteLine("Links:");
foreach (LinkDescription link in result.Links)
{
Console.WriteLine("\t{0}: {1}\tCall Type: {2}", link.Rel, link.Href, link.Method);
}
Console.WriteLine("Capture Ids: ");
foreach (PurchaseUnit purchaseUnit in result.PurchaseUnits)
{
foreach (Capture capture in purchaseUnit.Payments.Captures)
{
Console.WriteLine("\t {0}", capture.Id);
}
}
AmountWithBreakdown amount = result.PurchaseUnits[0].AmountWithBreakdown;
Console.WriteLine("Buyer:");
Console.WriteLine("\tEmail Address: {0}\n\tName: {1} {2}\n",
result.Payer.Email,
result.Payer.Name.GivenName,
result.Payer.Name.Surname);
}
return(result);
}
public async static Task <HttpResponse> CaptureOrder(string OrderId, bool debug = false)
{
var request = new OrdersCaptureRequest(OrderId);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
var response = await Client().Execute(request);
if (debug)
{
//var result = response.Result<Order>();
//Console.WriteLine("Status: {0}", result.Status);
//Console.WriteLine("Order Id: {0}", result.Id);
//Console.WriteLine("Intent: {0}", result.CheckoutPaymentIntent);
//Console.WriteLine("Links:");
//foreach (PayPalCheckoutSdk.Orders.LinkDescription link in result.Links)
//{
// Console.WriteLine("\t{0}: {1}\tCall Type: {2}", link.Rel, link.Href, link.Method);
//}
//Console.WriteLine("Capture Ids: ");
//foreach (PurchaseUnit purchaseUnit in result.PurchaseUnits)
//{
// foreach (PayPalCheckoutSdk.Orders.Capture capture in purchaseUnit.Payments.Captures)
// {
// Console.WriteLine("\t {0}", capture.Id);
// }
//}
//AmountWithBreakdown amount = result.PurchaseUnits[0].AmountWithBreakdown;
//Console.WriteLine("Buyer:");
//Console.WriteLine("\tEmail Address: {0}\n\tName: {1} {2}\n",
// result.Payer.Email,
// result.Payer.Name.GivenName,
// result.Payer.Name.Surname);
//Console.WriteLine("Response JSON:\n{0}", PayPalClient.ObjectToJSONString(result));
}
return(response);
}
public async Task <PaypalOrder> CaptureOrder(string transaction)
{
PayPalCheckoutSdk.Core.PayPalEnvironment environment = CreateEnvironment();
var client = new PayPalHttpClient(environment);
var request = new OrdersCaptureRequest(transaction);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
try
{
HttpResponse response = await client.Execute(request);
PaypalOrder order = response.Result <PaypalOrder>();
return(order);
}
catch (HttpException httpException)
{
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
throw httpException;
}
}
public async Task <HttpResponse> CaptureOrder(string OrderId, bool debug = false)
{
var request = new OrdersCaptureRequest(OrderId);
request.Prefer("return=representation");
request.RequestBody(new OrderActionRequest());
//3. Call PayPal to capture an order
var response = await PayPalClient.Client(_configuration).Execute(request);
//4. Save the capture ID to your database. Implement logic to save capture to your database for future reference.
if (debug)
{
var result = response.Result <Order>();
Console.WriteLine("Status: {0}", result.Status);
Console.WriteLine("Order Id: {0}", result.Id);
Console.WriteLine("Intent: {0}", result.CheckoutPaymentIntent);
Console.WriteLine("Links:");
foreach (PayPalCheckoutSdk.Orders.LinkDescription link in result.Links)
{
Console.WriteLine("\t{0}: {1}\tCall Type: {2}", link.Rel, link.Href, link.Method);
}
Console.WriteLine("Capture Ids: ");
foreach (PurchaseUnit purchaseUnit in result.PurchaseUnits)
{
foreach (PayPalCheckoutSdk.Orders.Capture capture in purchaseUnit.Payments.Captures)
{
Console.WriteLine("\t {0}", capture.Id);
}
}
AmountWithBreakdown amount = result.PurchaseUnits[0].AmountWithBreakdown;
Console.WriteLine("Buyer:");
Console.WriteLine("\tEmail Address: {0}\n\tName: {1}\n\tPhone Number: {2}{3}", result.Payer.Email, result.Payer.Name.FullName, result.Payer.PhoneWithType.PhoneNumber.CountryCallingCode, result.Payer.PhoneWithType.PhoneNumber.NationalNumber);
}
return(response);
}
