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")); } }