public static async Task <Payment> ExecutePayment(string paymentId, string payerId)
{
var client = PayPalConfiguration.GetClient();
var paymentExecution = new PaymentExecution()
{
PayerId = payerId
};
var payment = new Payment()
{
Id = paymentId
};
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
request.RequestBody(paymentExecution);
try
{
//TODO - ASYNC
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
return(response.Result <Payment>());
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
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 <IActionResult> ExecutePayment(string paymentId, string token, string PayerID)
{
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
request.RequestBody(new PaymentExecution()
{
PayerId = PayerID
});
try
{
HttpResponse response = await _clientPayPal.Execute(request);
HttpStatusCode statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
if (result.State == "approved")
{
return(RedirectToAction(nameof(Success)));
}
else
{
return(RedirectToAction(nameof(Error)));
}
}
catch (HttpException httpException)
{
HttpStatusCode statusCode = httpException.StatusCode;
string debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(RedirectToAction(nameof(Error)));
}
}
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 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);
}
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 <ActionResult> ExecutePayment(PaymentExecuteVm model)
{
var accessToken = await GetAccessToken();
var user = await RetrieveUser();
//var currentUser = await _workContext.GetCurrentUser();
Order order = _orderRepository.GetBy(user.Bills.Last().BillId);
if (order == null)
{
return(NotFound());
}
//var order = orderCreateResult.Value;
var payment = new Payment()
{
OrderId = order.BillId,
PaymentFee = 1m,
Amount = order.BillTotal / 23000,
PaymentMethod = "Paypal Express",
CreatedOn = DateTimeOffset.UtcNow,
};
var httpClient = _httpClientFactory.CreateClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var paymentExecuteRequest = new PaymentExecuteRequest
{
payer_id = model.payerID
};
var response = await httpClient.PostAsJsonAsync($"https://api{PaypalExpressConfig.EnvironmentUrlPart}.paypal.com/v1/payments/payment/{model.paymentID}/execute", paymentExecuteRequest);
var responseBody = await response.Content.ReadAsStringAsync();
dynamic responseObject = JObject.Parse(responseBody);
if (response.IsSuccessStatusCode)
{
// Has to explicitly declare the type to be able to get the propery
string payPalPaymentId = responseObject.id;
ICollection <OrderItem> OrderItem = RetrieveOrderItem(order);
OrderItem.ToList().ForEach(bl => bl.Validity = Validity.Valid);
_userRepository.SaveChanges();
//return RedirectToAction(nameof(CheckoutController.Thanks), "Checkout", new{ Id=order.BillId});
return(Ok(new { Status = "success", OrderId = order.BillId }));
}
//payment.Status = PaymentStatus.Failed;
//payment.FailureMessage = responseBody;
//_paymentRepository.Add(payment);
//order.OrderStatus = OrderStatus.PaymentFailed;
//await _paymentRepository.SaveChangesAsync();
string errorName = responseObject.name;
string errorDescription = responseObject.message;
return(BadRequest($"{errorName} - {errorDescription}"));
}
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 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 <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 <ActionResult> ExecutePayment(PaymentExecuteVm model)
{
var accessToken = await GetAccessToken();
var currentUser = await _workContext.GetCurrentUser();
var orderCreateResult = await _orderService.CreateOrder(currentUser, "PaypalExpress", OrderStatus.PendingPayment);
if (!orderCreateResult.Success)
{
return(BadRequest(orderCreateResult.Error));
}
var order = orderCreateResult.Value;
var payment = new Payment()
{
OrderId = order.Id,
PaymentFee = CalculatePaymentFee(order.OrderTotal),
Amount = order.OrderTotal + CalculatePaymentFee(order.OrderTotal),
PaymentMethod = "Paypal Express",
CreatedOn = DateTimeOffset.UtcNow,
};
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var paymentExecuteRequest = new PaymentExecuteRequest
{
payer_id = model.payerID
};
var response = await httpClient.PostJsonAsync($"https://api{_setting.Value.EnvironmentUrlPart}.paypal.com/v1/payments/payment/{model.paymentID}/execute", paymentExecuteRequest);
var responseBody = await response.Content.ReadAsStringAsync();
dynamic responseObject = JObject.Parse(responseBody);
if (response.IsSuccessStatusCode)
{
// Has to explicitly declare the type to be able to get the propery
string payPalPaymentId = responseObject.id;
payment.Status = PaymentStatus.Succeeded;
payment.GatewayTransactionId = payPalPaymentId;
_paymentRepository.Add(payment);
await _paymentRepository.SaveChangesAsync();
return(Ok(new { status = "success" }));
}
payment.Status = PaymentStatus.Failed;
payment.FailureMessage = responseBody;
_paymentRepository.Add(payment);
await _paymentRepository.SaveChangesAsync();
string errorName = responseObject.name;
string errorDescription = responseObject.message;
return(BadRequest($"{errorName} - {errorDescription}"));
}
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}'");
}
}
private async Task <PayPal.v1.Payments.Payment> ExecutePayment(string payerId, string paymentId)
{
var environment = new SandboxEnvironment(_configuration["Service:Paypal:ClientId"], _configuration["Service:Paypal:ClientSecret"]);
var client = new PayPalHttpClient(environment);
var paymentExecution = new PaymentExecution {
PayerId = payerId
};
var paymentExecutionRequest = new PaymentExecuteRequest(paymentId).RequestBody(paymentExecution);
var response = await Task.Run(() => client.Execute <PaymentExecuteRequest>(paymentExecutionRequest));
return(response.Result <PayPal.v1.Payments.Payment>());
}
public async Task <string> ExecutePayment(string paymentId, string token, string payerId, string email)
{
var environment = new SandboxEnvironment("AV8B5CBqWFqiUEBdhbe2rBVqX0RwNjY74nORYSEI3P8WZ-rRzRxXd1H0pA_qrywn0MCZuXzg3x-WwDeY", "EL-1QQduQKljgE0uHFs6WKAM4JtYrbf8CzOisxNCczPvdnkQYQDT1-rCM1W1dYM3Dhu8L9AcwqwhKdZH");
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>();
//PayerId en payment opslaan in DB
var employee = _context.Employees.Find(email);
employee.Balance = employee.Balance + 10;
Models.Transaction transaction = new Models.Transaction()
{
Amount = 10,
DateTime = DateTime.UtcNow,
Employee = employee,
employeeEmail = email,
ProviderName = "PayPal",
ProviderTransactionId = paymentId,
TransactionType = "ExternalTopUp"
};
try
{
_context.Add(transaction);
_context.Update(employee);
await _context.SaveChangesAsync();
return("Complete");
}
catch (SqlException error)
{
_logger.LogError("While running this error showed up:", error);
return("Failed");
}
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return("Failed");
}
}
public async Task <bool> ExecutePayment(string paypalId, string payerId)
{
PaymentExecuteRequest request = new PaymentExecuteRequest(paypalId);
request.RequestBody(new PaymentExecution()
{
PayerId = payerId
});
var response = await Client.Execute(request);
Payment result = response.Result <Payment>();
return(result.State.ToLower() == "approved");
}
public async Task <IActionResult> Execute(string attemptId, [FromQuery] string payerID, string paymentId)
{
var clientId = this.configuration.GetSection("PayPal").GetSection("clientId").Value;
var secret = this.configuration.GetSection("PayPal").GetSection("secret").Value;
var environment = new SandboxEnvironment(clientId, secret);
var client = new PayPalHttpClient(environment);
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
request.RequestBody(new PaymentExecution()
{
PayerId = payerID,
});
var response = await client.Execute <PaymentExecuteRequest>(request);
var statusCode = response.StatusCode;
if (statusCode.ToString() == "OK")
{
var attempt = await this.paymentsService.GetPaymentAttempt(attemptId);
var userId = attempt.StudentId;
var semesterId = attempt.SemesterId;
var semester = await this.paymentsService
.GetSemester <PaymentSemesterViewModel>(semesterId);
await this.paymentsService.RegisterUserToSemesterAsync(userId, semesterId);
foreach (var subject in semester.Subjects)
{
await this.paymentsService.RegisterUserToSubjectAsync(userId, subject.Id);
}
await this.paymentsService.CreatePaymentAsync(userId, semesterId);
this.TempData["message"] = $"Payment status code {statusCode}";
return(this.RedirectToAction("Index", "Home"));
}
else
{
// Delete paymentAttmept
this.TempData["message"] = $"Payment status code {statusCode}";
return(this.RedirectToAction("Index", "Home"));
}
}
public async Task <ActionResult> ExecutePayment(PaymentExecuteVm model)
{
var accessToken = await GetAccessToken();
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var paymentExecuteRequest = new PaymentExecuteRequest
{
payer_id = model.payerID
};
var response = await httpClient.PostJsonAsync($"https://api.sandbox.paypal.com/v1/payments/payment/{model.paymentID}/execute", paymentExecuteRequest);
var responseBody = await response.Content.ReadAsStringAsync();
response.EnsureSuccessStatusCode();
return(Ok(new { status = "success" }));
}
public async Task <string> ExecutePaymentAsync(PayPalExecutePaymentRequestInput input)
{
var request = new PaymentExecuteRequest(input.PaymentId);
request.RequestBody(new PaymentExecution()
{
PayerId = input.PayerId
});
var response = await _client.Execute(request);
var payment = response.Result <Payment>();
if (payment.State != "approved")
{
throw new UserFriendlyException(L("PaymentFailed"));
}
return(payment.Id);
}
public async Task <ActionResult> ExecutePayment(PaymentExecuteVm model)
{
var accessToken = await GetAccessToken();
var currentUser = await _workContext.GetCurrentUser();
var order = await _orderService.CreateOrder(currentUser, "PaypalExpress");
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var paymentExecuteRequest = new PaymentExecuteRequest
{
payer_id = model.payerID
};
var response = await httpClient.PostJsonAsync($"https://api{_setting.Value.EnvironmentUrlPart}.paypal.com/v1/payments/payment/{model.paymentID}/execute", paymentExecuteRequest);
var responseBody = await response.Content.ReadAsStringAsync();
response.EnsureSuccessStatusCode();
dynamic payPalPayment = JObject.Parse(responseBody);
// Has to explicitly declare the type to be able to get the propery
string payPalPaymentId = payPalPayment.id;
var payment = new Payment()
{
OrderId = order.Id,
Amount = order.OrderTotal,
PaymentMethod = "Stripe",
CreatedOn = DateTimeOffset.UtcNow,
GatewayTransactionId = payPalPaymentId
};
order.OrderStatus = Orders.Models.OrderStatus.Processing;
_paymentRepository.Add(payment);
await _paymentRepository.SaveChangesAsync();
return(Ok(new { status = "success" }));
}
/// <summary>
/// Execute payment
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <ResponsePaypal> ExecutePaymentAsync(PaymentExecuteVm model)
{
var userRequest = await _userManager.GetCurrentUserAsync();
if (!userRequest.IsSuccess)
{
return(new ResponsePaypal {
Message = "User not Found", IsSuccess = false
});
}
var orderRequest = await _orderProductService.GetOrderByIdAsync(model.OrderId);
if (!orderRequest.IsSuccess)
{
return(new ResponsePaypal {
Message = "Order not Found", IsSuccess = false
});
}
var order = orderRequest.Result;
var accessToken = await GetAccessTokenAsync();
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var paymentExecuteRequest = new PaymentExecuteRequest {
PayerId = model.PayerId
};
var response = await httpClient.PostJsonAsync(
$"https://api{_payPalOptions.Value.EnvironmentUrlPart}.paypal.com/v1/payments/payment/{model.PaymentId}/execute",
paymentExecuteRequest);
var responseBody = await response.Content.ReadAsStringAsync();
dynamic responseObject = JObject.Parse(responseBody);
var payment = new Payment
{
PaymentMethodId = "Paypal",
GatewayTransactionId = model.PaymentId,
PaymentStatus = PaymentStatus.Failed,
Total = order.Total,
UserId = userRequest.Result.Id,
FailureMessage = responseBody
};
if (response.IsSuccessStatusCode)
{
await _orderProductService.ChangeOrderStateAsync(model.OrderId, OrderState.PaymentReceived);
payment.PaymentStatus = PaymentStatus.Succeeded;
await _paymentService.AddPaymentAsync(model.OrderId, payment);
return(new ResponsePaypal
{
Message = "Payment received",
OrderId = model.OrderId,
IsSuccess = true
});
}
await _orderProductService.ChangeOrderStateAsync(model.OrderId, OrderState.PaymentFailed);
payment.PaymentStatus = PaymentStatus.Failed;
await _paymentService.AddPaymentAsync(model.OrderId, payment);
string errorName = responseObject.name;
string errorDescription = responseObject.message;
return(new ResponsePaypal {
Message = $"{errorName} - {errorDescription}", IsSuccess = false
});
}
}
public async Task <PayPalPaymentExecuteResultDto> ExecutePayPalPaymentAsync(string paymentId, string token, string payerId)
{
var environment = new SandboxEnvironment(_payPalSettings.ClientId, _payPalSettings.ClientSecret);
var client = new PayPalHttpClient(environment);
var steamUser = _steamUserService.GetCurrentRequestSteamUser();
PaymentExecution paymentExecution = new PaymentExecution()
{
PayerId = payerId
};
PaymentExecution payment = new PaymentExecution()
{
PayerId = payerId
};
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
request.RequestBody(payment);
HttpStatusCode statusCode;
Payment paymentExecutionResult = null;
_logger.LogInformation($"Preparation for payment execution against PayPal API");
HttpStatusCode responseStatusCode;
try
{
BraintreeHttp.HttpResponse response = await client.Execute(request);
statusCode = response.StatusCode;
paymentExecutionResult = response.Result <Payment>();
await _payPalExecutedPaymentService.CreateAsync(paymentExecutionResult);
_logger.LogInformation($"PayPal payment execution result, {nameof(paymentExecutionResult)}: {JsonConvert.SerializeObject(paymentExecutionResult)}");
}
catch (BraintreeHttp.HttpException e)
{
responseStatusCode = e.StatusCode;
var debugId = e.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
_logger.LogError(e, $"PayPal payment execution: Failed\nSteamUserID: {steamUser.Id}\nSteamUserUID: {steamUser.Uid}\nDebugId: {debugId}\nStatusCode: {responseStatusCode}");
return(new PayPalPaymentExecuteResultDto
{
State = PaymentExecutionResultEnum.Failed,
FailedReason = debugId
});
}
if (paymentExecutionResult.State == "approved")
{
var updateSteamUserShopBalanceResult = await AddFundsToSteamUserShopAsync(paymentExecutionResult);
if (!updateSteamUserShopBalanceResult)
{
return new PayPalPaymentExecuteResultDto
{
State = PaymentExecutionResultEnum.Failed,
FailedReason = "Error on adding funds, please contact support!"
}
}
;
return(new PayPalPaymentExecuteResultDto
{
State = PaymentExecutionResultEnum.Success,
AmountPaid = paymentExecutionResult
.Transactions.First()
.RelatedResources.First()
.Sale.Amount.Total,
CurrentBalance = _steamUserService.GetCurrentRequestSteamUserShop().Balance
});
}
return(new PayPalPaymentExecuteResultDto
{
State = PaymentExecutionResultEnum.Failed,
FailedReason = "Payment has not been approved!"
});
}
public async Task <IActionResult> PayPalHoanThanh()
{
var model = _context.loais.ToList();
ViewBag.model = model;
var paymentId = Request.Query["paymentId"];
var payerId = Request.Query["PayerID"];
var environment = new SandboxEnvironment(_clientId, _secretKey);
var client = new PayPalHttpClient(environment);
var paymentExecution = new PaymentExecution()
{
PayerId = payerId
};
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
request.RequestBody(paymentExecution);
try
{
var response = await client.Execute(request);
var statusCode = response.StatusCode.ToString();
if (statusCode == "OK")
{
if (_orderId == 0)
{
var orderId = SessionHelper.Get <long>(HttpContext.Session, "orderId");
_orderId = orderId;
}
SessionHelper.Set(HttpContext.Session, "orderId", 0);
var oder = _context.Oders.SingleOrDefault(m => m.ID == _orderId);
if (oder == null)
{
return(NotFound());
}
oder.Status = true;
_context.Update(oder);
_context.SaveChanges();
SessionHelper.Set(HttpContext.Session, "cart", "");
return(View());
}
else
{
return(Redirect("/cart/that-bai"));
}
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(Redirect("/cart/that-bai"));
}
}
