public static HttpClient Client()
{
PayPalEnvironment environment = new SandboxEnvironment(clientId, secret);
var client = new PayPalHttpClient(environment);
return(client);
}
public ServiceManager(ICheckoutAttributeParser checkoutAttributeParser,
ICurrencyService currencyService,
IGenericAttributeService genericAttributeService,
ILogger logger,
IOrderTotalCalculationService orderTotalCalculationService,
IPriceCalculationService priceCalculationService,
IShippingPluginManager shippingPluginManager,
IShoppingCartService shoppingCartService,
IStoreContext storeContext,
ITaxService taxService,
IWorkContext workContext,
CurrencySettings currencySettings,
PayPalSmartPaymentButtonsSettings settings)
{
_checkoutAttributeParser = checkoutAttributeParser;
_currencyService = currencyService;
_genericAttributeService = genericAttributeService;
_logger = logger;
_orderTotalCalculationService = orderTotalCalculationService;
_priceCalculationService = priceCalculationService;
_shippingPluginManager = shippingPluginManager;
_shoppingCartService = shoppingCartService;
_storeContext = storeContext;
_taxService = taxService;
_workContext = workContext;
_currencySettings = currencySettings;
_settings = settings;
_client = _settings.UseSandbox
? new PayPalHttpClient(new SandboxEnvironment(_settings.ClientId, _settings.SecretKey))
: new PayPalHttpClient(new LiveEnvironment(_settings.ClientId, _settings.SecretKey));
}
public async Task <Payment> CreatePaymentAsync(PaypalTransaction transaction)
{
PayPalEnvironment environment;
if (isSandboxMode)
{
environment = new SandboxEnvironment(clientId, clientSecret);
}
else
{
environment = new LiveEnvironment(clientId, clientSecret);
}
var client = new PayPalHttpClient(environment);
try
{
var payment = CreatePayment(transaction);
var request = new PaymentCreateRequest().RequestBody(payment);
var response = await client.Execute(request);
var statusCode = response.StatusCode;
var result = response.Result <Payment>();
return(result);
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(null);
}
}
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 <IActionResult> Execute(string paymentId, string PayerId)
{
//SandboxEnvironment(clientId, clientSerect)
string clientId = "ATEyDHMWKozlcGDf5yNduG92WTeajJf9gqXc34Dd0AU7LbWgFvH3qY_8ImvFfZls5uZMzaoeZAdZBCrm";
string clientSecret = "EH1J-u4MfbsyBENy8zBoVHHOnU9DMsDRjGDaXwfZltNEVc3rv_t26ANZ_L2Z4eQlS12oRnUj_Zr8dizO";
var environment = new SandboxEnvironment(clientId, clientSecret);
var client = new PayPalHttpClient(environment);
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
request.RequestBody(new PaymentExecution()
{
PayerId = PayerId
});
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(RedirectToAction("Success"));
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(RedirectToAction("Fail"));
}
}
public async Task <PaypalOrder> CreatePaypalOrder(IEnumerable <PurchaseUnitRequest> purchaseUnits, ApplicationContext applicationContext)
{
PayPalCheckoutSdk.Core.PayPalEnvironment environment = CreateEnvironment();
var client = new PayPalHttpClient(environment);
var payment = new OrderRequest()
{
CheckoutPaymentIntent = "CAPTURE",
PurchaseUnits = purchaseUnits.ToList(),
ApplicationContext = applicationContext
};
//https://developer.paypal.com/docs/api/orders/v2/#orders_create
var request = new OrdersCreateRequest();
request.Prefer("return=representation");
request.RequestBody(payment);
try
{
var response = await client.Execute(request);
var result = response.Result <PaypalOrder>();
return(result);
}
catch (HttpException httpException)
{
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
throw httpException;
}
}
public async Task <IActionResult> Execute(string paymentId, string PayerId)
{
//SandboxEnvironment(clientId, clientSerect)
string clientId = "AYOwjSPbuM8boAckmyHBzPF3fS5jkqsE6-i-fd_2Y66bMFW7t9miYPklGgcNAdXweQa4ijsjCRQnElL1";
string clientSecret = "EL485ImsKFuaWVHj8YqVRNwzc1-q8xsmFMaDnFyvBTwH5JT4zqyGe7dLT9F4-Q64-ebEaix79UYxnO4H";
var environment = new SandboxEnvironment(clientId, clientSecret);
var client = new PayPalHttpClient(environment);
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
request.RequestBody(new PaymentExecution()
{
PayerId = PayerId
});
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(RedirectToAction("Success"));
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(RedirectToAction("Fail"));
}
}
public async Task <object> Process(PaymentModel.Payment payment)
{
if (_paypalSettings == null)
{
throw new NullReferenceException("Paypal settings cannot be null.");
}
var env = new SandboxEnvironment(_paypalSettings.ClientId, _paypalSettings.ClientSecret);
var client = new PayPalHttpClient(env);
var paymentDetails = new PaymentMapper(payment).GetPaymentDetails();
var request = new PaymentCreateRequest();
request.RequestBody(paymentDetails);
try
{
var response = await client.Execute(request);
var result = response.Result <PayPal.v1.Payments.Payment>();
var json = JsonConvert.SerializeObject(result);
return(result);
}
catch (Exception ex)
{
return(ex);
}
}
public async Task <Payment> ExecutePaymentAsync(PayVM payVM)
{
var paymentId = payVM.PaymentID;
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
var body = new PaymentExecution()
{
PayerId = payVM.PayerID
};
request.RequestBody(body);
string ClientID = this.configuration.GetSection("ClientID").Get <string>();
string Secret = this.configuration.GetSection("Secret").Get <string>();
var environment = new SandboxEnvironment(ClientID, Secret);
var client = new PayPalHttpClient(environment);
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(result);
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(new Payment());
}
}
public async Task <Payment> CreatePayment(string intent, string paymentMethod = "credit_card", string invoiceNumber = null)
{
string ClientID = this.configuration.GetSection("ClientID").Get <string>();
string Secret = this.configuration.GetSection("Secret").Get <string>();
var environment = new SandboxEnvironment(ClientID, Secret);
var client = new PayPalHttpClient(environment);
var request = new PaymentCreateRequest();
request.RequestBody(BuildRequestBody(intent, paymentMethod, invoiceNumber));
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(result);
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(new Payment());
}
}
public static TransactionResult ProcessExecution(Order order, PaymentReturnModel returnModel, PaypalWithRedirectSettings settings)
{
var transAmount = order.OrderTotal - order.StoreCreditAmount;
var payment = new PaymentExecution()
{
PayerId = returnModel.PayerId,
Transactions = new List <CartBase>()
{
new CartBase()
{
Amount = new Amount()
{
Currency = order.CurrencyCode,
Total = transAmount.ToString("N")
}
}
}
};
var pcRequest = new PaymentExecuteRequest(returnModel.PaymentId);
pcRequest.RequestBody(payment);
var environment = GetEnvironment(settings);
var client = new PayPalHttpClient(environment);
var transactionResult = new TransactionResult();
try
{
var response = client.Execute(pcRequest).Result;
var result = response.Result <Payment>();
transactionResult.Success = true;
transactionResult.NewStatus = result.State == "approved" ? PaymentStatus.Complete : PaymentStatus.OnHold;
transactionResult.OrderGuid = order.Guid;
transactionResult.TransactionAmount = result.Transactions[0].Amount.Total.GetDecimal();
transactionResult.TransactionGuid = returnModel.PaymentId;
transactionResult.TransactionCurrencyCode = result.Transactions[0].Amount.Currency;
transactionResult.ResponseParameters = new Dictionary <string, object>()
{
{ "id", result.Id },
{ "payerId", returnModel.PayerId },
{ "paymentId", returnModel.PaymentId },
{ "createTime", result.CreateTime },
{ "failureReason", result.FailureReason },
{ "experienceProfileId", result.ExperienceProfileId },
{ "noteToPayer", result.NoteToPayer },
{ "intent", result.Intent },
{ "state", result.State },
{ "updateTime", result.UpdateTime },
{ "saleId", result.Transactions[0].RelatedResources[0].Sale.Id }
};
}
catch (BraintreeHttp.HttpException ex)
{
transactionResult.Success = false;
transactionResult.Exception = ex;
}
return(transactionResult);
}
private static async Task <BraintreeHttp.HttpResponse> ExecutePayPalRequest(
PayPalHttpClient client,
PaymentCreateRequest request)
{
SynchronizationContext.SetSynchronizationContext(null);
return(await client.Execute(request).ConfigureAwait(false));
}
public async Task <CourseSubscribeInputModel> CapturePaymentAsync(string token)
{
PayPalEnvironment env = GetPayPalEnvironment(options.CurrentValue);
PayPalHttpClient client = new PayPalHttpClient(env);
OrdersCaptureRequest request = new(token);
request.RequestBody(new OrderActionRequest());
request.Prefer("return=representation");
try
{
HttpResponse response = await client.Execute(request);
Order result = response.Result <Order>();
PurchaseUnit purchaseUnit = result.PurchaseUnits.First();
Capture capture = purchaseUnit.Payments.Captures.First();
// $"{inputModel.CourseId}/{inputModel.UserId}"
string[] customIdParts = purchaseUnit.CustomId.Split('/');
int courseId = int.Parse(customIdParts[0]);
string userId = customIdParts[1];
return(new CourseSubscribeInputModel
{
CourseId = courseId,
UserId = userId,
Paid = new(Enum.Parse <Currency>(capture.Amount.CurrencyCode), decimal.Parse(capture.Amount.Value, CultureInfo.InvariantCulture)),
TransactionId = capture.Id,
PaymentDate = DateTime.Parse(capture.CreateTime, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal),
PaymentType = "Paypal"
});
}
public static async Task <bool> ExecutePayment(string paymentId, string payerId)
{
SandboxEnvironment environment = new SandboxEnvironment(
"AcsZudPzaw7QNmu68Q15SdtKMCM0HJMKO-q-Lp1IXgLwqe-Dt9CWOYqsBtZ_QiS2hVVL0o50BK8xW0Dk",
"EJo0Vn_JKFf5qq4pN6zOKm50fmYN4dI8ZTeB5j2vl5YtWRnKeAPOvXK2WZ4faxGA8QaUM1KhVj-kF8kr");
_client = new PayPalHttpClient(environment);
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
request.RequestBody(new PaymentExecution
{
PayerId = payerId
});
try
{
HttpResponse response = await _client.Execute(request);
HttpStatusCode Status = response.StatusCode;
return(Status.ToString() == "OK");
}
catch (HttpException)
{
return(false);
}
}
public async static Task <HttpResponse> CreateOrder2(bool debug = false)
{
var request = new OrdersCreateRequest();
request.Prefer("return=representation");
request.RequestBody(BuildRequestBody());
PayPalHttpClient m_PayPalHttpClient = new PayPalHttpClient(environment());
var response = await m_PayPalHttpClient.Execute(request);
if (debug)
{
var result = response.Result <PayPalCheckoutSdk.Orders.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);
}
AmountWithBreakdown amount = result.PurchaseUnits[0].AmountWithBreakdown;
Console.WriteLine("Total Amount: {0} {1}", amount.CurrencyCode, amount.Value);
}
return(response);
}
public async Task <IActionResult> Execute(string paymentId, string PayerId)
{
var environment = new SandboxEnvironment("Acc2-UPp-z25_Olh73h5VZB3XjR16eUKtL2lHoIc27IJn8-2f5R8-Kish229pYjzdy18KR8khHJRQO5Q", "EIb_0hbZQPAEioCGLAzVpn87zRswB7zLAoRtda06Oc4IhrDAmtGYAI2z6xYplX6TdARnsuVh2TC3tHNM");
var client = new PayPalHttpClient(environment);
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
request.RequestBody(new PaymentExecution()
{
PayerId = PayerId
});
await _context.Orders.Where(m => m.Paymentid == paymentId).ForEachAsync(m => m.IsConfirm = true);
await _context.SaveChangesAsync();
try
{
BraintreeHttp.HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(Redirect("sold"));
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(BadRequest(debugId));
}
}
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;
}
}
public async Task <Payment> ExecutePayment(PaymentExecution objPaymentExecution, string paymentId)
{
var client = new PayPalHttpClient(environment);
string intent = "sale";
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);;
request.RequestBody(objPaymentExecution);
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(result);
}
catch (Exception objException)
{
throw objException;
}
}
public async Task <string> PaypalPayment(double total)
{
var environment = new SandboxEnvironment(configuration["PayPal:clientId"], configuration["PayPal:secret"]);
var client = new PayPalHttpClient(environment);
var payment = new Payment()
{
Intent = "sale",
Transactions = new List <Transaction>()
{
new Transaction()
{
Amount = new Amount()
{
Total = total.ToString(),
Currency = "USD"
}
}
},
RedirectUrls = new RedirectUrls()
{
CancelUrl = configuration["PayPal:cancelUrl"],
ReturnUrl = configuration["PayPal:returnUrl"]
},
Payer = new Payer()
{
PaymentMethod = "paypal"
}
};
PaymentCreateRequest request = new PaymentCreateRequest();
request.RequestBody(payment);
string paypalRedirectUrl = null;
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
var links = result.Links.GetEnumerator();
while (links.MoveNext())
{
LinkDescriptionObject lnk = links.Current;
if (lnk.Rel.ToLower().Trim().Equals("approval_url"))
{
//saving the payapalredirect URL to which user will be redirected for payment
paypalRedirectUrl = lnk.Href;
}
}
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
}
return(paypalRedirectUrl);
}
public async Task <PaymentServiceResponseDTO> CreateInvoice(Domain.Order order)
{
var environment = new SandboxEnvironment("AZTu0aTctY3TsQRanLBGIjRYVhzo7rc25etnkVduypxV38zDdRja0Z6_adpN7nakww62w667wNh4_OKT", "EPT6TcCPEuAbNrCatN0_FyrWFTGtO6-1c77lhSj_pMrIx3o2V09BnpZnhLe3CfGO0wtW0IULHGI4yrGc");
var client = new PayPalHttpClient(environment);
int totalPrice = 0;
foreach (var product in order.ProductsInOrder)
{
totalPrice += product.Product.Price;
}
var payment = new Payment()
{
Intent = "sale",
Transactions = new List <Transaction>()
{
new Transaction()
{
ItemList = new ItemList(),
Amount = new Amount()
{
Total = totalPrice.ToString(),
Currency = "USD"
}
}
},
RedirectUrls = new RedirectUrls()
{
CancelUrl = "https://example.com/cancel",
ReturnUrl = "https://example.com/return"
},
Payer = new Payer()
{
PaymentMethod = "paypal"
}
};
PaymentCreateRequest request = new PaymentCreateRequest();
request.RequestBody(payment);
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(new PaymentServiceResponseDTO {
PaymentUrl = result.Links.FirstOrDefault(link => link.Rel == APPROVAL_URL).Href
});
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(null);
}
}
public override Task Execute(MessageData data)
{
var args = data.GetAs <Params>();
OrdersGetRequest request = new OrdersGetRequest(args.OrderId);
if (string.IsNullOrEmpty(clientId))
{
throw new CoflnetException("unavailable", "checkout via paypal has not yet been enabled, please contact an admin");
}
var client = new PayPalHttpClient(new LiveEnvironment(clientId, clientSecret));
//3. Call PayPal to get the transaction
PayPalHttp.HttpResponse response;
try
{
response = client.Execute(request).Result;
}
catch (Exception e)
{
dev.Logger.Instance.Error(e, "payPalPayment");
throw new CoflnetException("payment_failed", "The provided orderId has not vaid payment asociated");
}
//4. Save the transaction in your database. Implement logic to save transaction to your database for future reference.
var result = response.Result <Order>();
Console.WriteLine(JSON.Stringify(result));
Console.WriteLine("Retrieved Order Status");
Console.WriteLine("Status: {0}", result.Status);
Console.WriteLine("Order Id: {0}", result.Id);
AmountWithBreakdown amount = result.PurchaseUnits[0].AmountWithBreakdown;
Console.WriteLine("Total Amount: {0} {1}", amount.CurrencyCode, amount.Value);
if (result.Status != "COMPLETED")
{
throw new CoflnetException("order_incomplete", "The order is not yet completed");
}
if (UsedIds.Contains(args.OrderId))
{
throw new CoflnetException("payment_timeout", "the provied order id was already used");
}
if (DateTime.Parse(result.PurchaseUnits[0].Payments.Captures[0].UpdateTime) < DateTime.Now.Subtract(TimeSpan.FromHours(1)))
{
throw new CoflnetException("payment_timeout", "the provied order id is too old, please contact support for manual review");
}
var user = data.User;
var days = args.Days;
var transactionId = result.Id;
UserService.Instance.SavePurchase(user, days, transactionId);
UsedIds.Add(args.OrderId);
FileController.AppendLineAs("purchases", JSON.Stringify(result));
return(data.Ok());
}
public override async Task <IOrder> ChargeAsync(PayPalChargeBindings bindings, CancellationToken cancellationToken = default(CancellationToken))
{
var environment = configuration.Environment == "production" ?
new SandboxEnvironment(configuration.ClientIdProduction, configuration.SecretProduction) :
new SandboxEnvironment(configuration.ClientIdSandbox, configuration.SecretSandbox);
var client = new PayPalHttpClient(environment);
var request = new PaymentExecuteRequest(bindings.PaymentId);
request.RequestBody(new PaymentExecution()
{
PayerId = bindings.PayerId
});
try
{
var response = await client.Execute(request);
var statusCode = response.StatusCode;
var result = response.Result <PayPalPayment>();
var order = await this.orderService.GetByIdAsync(bindings.OrderId, cancellationToken);
var payments = new List <OurPayment>();
foreach (var transaction in result.Transactions)
{
if (!Decimal.TryParse(transaction.Amount.Total, out decimal amount))
{
amount = 0;
}
var payment = new OurPayment()
{
Title = "Paypal Payment",
Provider = Name,
Reference = $"{bindings.PaymentId}",
Status = PaymentStatus.Paid,
Date = DateTime.UtcNow,
Method = PaymentMethod.Electronic,
Details = $"Payment Order #{order.Reference}: {transaction.Amount.Total} {transaction.Amount.Currency}",
Currency = transaction.Amount.Currency,
Amount = amount
};
payments.Add(payment);
await orderService.AddPayment(order, payment, cancellationToken);
}
return(order);
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
// TODO: better error text
throw new AppException($"impossible to create payment, statusCode: '{statusCode}' paypal debug Id '{debugId}'");
}
}
public async Task <string> CreateInvoice(Basket basket)
{
var environment = new SandboxEnvironment("AUcBbHNGlkF8pMud0Imkq_lEkvMeN2ebB3_fDS7-NIfvndr5x7maf6ol2WczTBEG5d4qoXHckCMqID5u", "EH8ICa3Sh-oEy_DXHDAzRpl8pjLWD2bphuGoUJeO39U-AqYr3ycFSi_icSjfz6lgz4O28VEuH91Ps33K");
var client = new PayPalHttpClient(environment);
int totalPrice = 0;
foreach (var product in basket.Products.ToList())
{
totalPrice += product.Cost;
}
var payment = new Payment()
{
Intent = "sale",
Transactions = new List <Transaction>()
{
new Transaction()
{
ItemList = new ItemList(),
Amount = new Amount()
{
Total = totalPrice.ToString(),
Currency = "USD"
}
}
},
RedirectUrls = new RedirectUrls()
{
CancelUrl = "https://example.com/cancel",
ReturnUrl = "https://example.com/return"
},
Payer = new Payer()
{
PaymentMethod = "paypal"
}
};
PaymentCreateRequest request = new PaymentCreateRequest();
request.RequestBody(payment);
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(result.Links.FirstOrDefault(link => link.Rel == APPROVAL_URL).Href);
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(null);
}
}
public PaymentService(IOptions <PaypalSettings> paypalSettings, IPaypalClientFactory paypalClientFactory,
IOrderTransactionService orderTransactionService, IDatabase database, IHttpContextReader httpContextReader)
{
this.paypalSettings = paypalSettings.Value;
this.orderTransactionService = orderTransactionService;
this.database = database;
this.httpContextReader = httpContextReader;
this.paypalClient = paypalClientFactory.CreateClient(this.paypalSettings);
}
public HttpClient Client()
{
// Creating a sandbox environment
PayPalEnvironment environment = new SandboxEnvironment(clientId, secret);
// Creating a client for the environment
PayPalHttpClient client = new PayPalHttpClient(environment);
return(client);
}
public PayPalHttpClient getClient()
{
// Creating a sandbox environment
var environment = new SandboxEnvironment(ClientId, ClientSecret);
// Creating a client for the environment
var client = new PayPalHttpClient(environment);
return(client);
}
//public static async Task<CreditCard> CreateCreditCard(CardModel card)
//{
// // ### 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 environment = new SandboxEnvironment("AXBzX3BK0EIKIf87NiLs0FF56f6CBINvplAEI-eGQA5UCzlpzpsu1GwG3Jbz_0UaMcGVn6QF9xifYafT", "EHX5uun_f-IokPZKeziZPr8bP_S7NScvdqpw13mXaaHJz2TSVlNhsY8TjHqM3PTSzeZnDjkjtc4SlvtR");
// var client = new PayPalHttpClient(environment);
// // Payment Resource
// var creditCard = new CreditCard()
// {
// BillingAddress = new Address()
// {
// City = card.City,
// CountryCode = card.Country,
// Line1 = card.Address1,
// Line2 = card.Address2,
// },
// Cvv2 = card.CVC,
// ExpireMonth = card.Exp_Month,
// ExpireYear = card.Exp_Year,
// LastName = card.Name,
// Number = card.CardNumber,
// Type = card.Type
// };
// FundingInstrument fundInstrument = new FundingInstrument();
// fundInstrument.CreditCard = creditCard;
// List<FundingInstrument> fundingInstrumentList = new List<FundingInstrument>();
// fundingInstrumentList.Add(fundInstrument);
// client.
// PaymentCreateRequest request = new PaymentCreateRequest();
// request.RequestBody(payment);
// // Create a payment using a valid APIContext
// try
// {
// HttpResponse response = await client.Execute(request);
// var statusCode = response.StatusCode;
// Payment result = response.Result<Payment>();
// return result;
// }
// catch (HttpException httpException)
// {
// var statusCode = httpException.StatusCode;
// var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
// }
//}
public static async Task <Payment> ExecutePayment(string paymentId, string payerId)
{
var environment = new SandboxEnvironment("AXBzX3BK0EIKIf87NiLs0FF56f6CBINvplAEI-eGQA5UCzlpzpsu1GwG3Jbz_0UaMcGVn6QF9xifYafT", "EHX5uun_f-IokPZKeziZPr8bP_S7NScvdqpw13mXaaHJz2TSVlNhsY8TjHqM3PTSzeZnDjkjtc4SlvtR");
var client = new PayPalHttpClient(environment);
// ### 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.
// Payment Resource
var payment = new Payment()
{
Intent = "sale",
Transactions = new List <Transaction>()
{
new Transaction()
{
Amount = new Amount()
{
Total = "10",
Currency = "USD"
}
}
},
RedirectUrls = new RedirectUrls()
{
CancelUrl = "https://example.com/cancel",
ReturnUrl = "https://example.com/return"
},
Payer = new Payer()
{
PaymentMethod = "paypal"
}
};
PaymentCreateRequest request = new PaymentCreateRequest();
request.RequestBody(payment);
// Create a payment using a valid APIContext
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(result);
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
}
return(null);
}
public async Task <string> PayPalPaymentAsync(int orderPrice)
{
const string CLIENT_ID = "Ab8zPbxBbiYu1TuE-3jyw0M6m41tBR4mhjXNDP1ZzQMEJ4JfQ9yJJy3qLT2LrO0oIrf-qpm7beMLAAXD";
const string CLIENT_SECRET = "EMSYp9szDMBOMFd-nag3_VbHHm7LieAVIFK4FZNtidyRfGpIQwhcnEfdwPlophxERxgkhHsUMRngbm09";
var environment = new SandboxEnvironment(CLIENT_ID, CLIENT_SECRET);
var client = new PayPalHttpClient(environment);
var payment = new Payment
{
Intent = "order",
Transactions = new List <Transaction>()
{
new Transaction()
{
Amount = new Amount()
{
Total = orderPrice.ToString(),
Currency = "USD"
}
}
},
RedirectUrls = new RedirectUrls()
{
CancelUrl = "https://example.com/cancel",
ReturnUrl = "https://example.com/return"
},
Payer = new Payer()
{
PaymentMethod = "paypal"
}
};
PaymentCreateRequest request = new PaymentCreateRequest();
request.RequestBody(payment);
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(response.StatusCode.ToString());
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(statusCode.ToString());
}
}
private HttpClient Client()
{
PayPalEnvironment environment =
new SandboxEnvironment(
CommonSecurityConstants.PaypalClientId,
CommonSecurityConstants.PaypalClientSecret);
PayPalHttpClient client = new PayPalHttpClient(environment);
return(client);
}
public PayPalGate(string clienntId, string secret)
{
_clientId = clienntId;
_secret = secret;
PayPalEnvironment environment = new PayPalEnvironment(_clientId, _secret, "https://api-m.paypal.com", "https://sarnado.club/");
// Creating a client for the environment
_client = new PayPalHttpClient(environment);
}
