public async Task <bool> MakePayment(CardData model, long value)
{
try
{
var tokenopt = new TokenCreateOptions
{
Card = new TokenCardOptions
{
Number = model.Number,
ExpMonth = model.ExpMonth,
ExpYear = model.ExpYear,
Cvc = model.Cvc
}
};
var serviceToken = new TokenService();
Token stripeToken = await serviceToken.CreateAsync(tokenopt);
var chargeopt = new ChargeCreateOptions
{
Amount = value,
//en az 50 cent lazim oldugu ucun usd etdim
Currency = "usd",
Description = "test",
Source = stripeToken.Id
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(chargeopt);
if (!charge.Paid)
{
return(false);
}
}
catch (Exception e)
{
return(false);
}
return(true);
}
public async Task<dynamic> PayAsync(string cardNumber, int month, int year, string cvc, int value)
{
try
{
StripeConfiguration.ApiKey = "sk_test_5c9O1EiPCGqYWXGXO31PY1I200lvNHeZKx";
var optionsToken = new TokenCreateOptions
{
Card = new CreditCardOptions
{
Number = cardNumber,
ExpMonth = month,
ExpYear = year,
Cvc = cvc
},
};
var serviceToken = new TokenService();
Token stripeToken = await serviceToken.CreateAsync(optionsToken);
var options = new ChargeCreateOptions
{
Amount = value,
Currency = "eur",
Description = "Test",
Source = stripeToken.Id
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(options);
return charge.Paid ? "success" : "failed";
}
catch (Exception e)
{
return e.Message;
}
}
public async Task <IActionResult> CancelConfirmed(int?bookingId, string stripeEmail, string stripeToken)
{
//gets the booking from the database
var booking = await _context.Bookings.FindAsync(bookingId);
//creates new objects required from the stripe API
if (!booking.PaymentType.ToString().Equals("FULL"))
{
//finds out how many days are between the booking and cancelling
var daysBetween = (booking.DepartureDate - DateTime.Now).TotalDays;
var price = booking.TotalPrice - booking.AmountPaid;
//creating the services required for stripe payment
var customerService = new CustomerService();
var chargeService = new ChargeService();
//creating a customer using the API
var customer = customerService.Create(new CustomerCreateOptions
{
Email = stripeEmail,
SourceToken = stripeToken
});
//charging the customer using the details from the booking
var charge = await chargeService.CreateAsync(new ChargeCreateOptions
{
Amount = Convert.ToInt32(price * 100),
Description = "Booking Id: " + booking.BookingId,
Currency = "gbp",
CustomerId = customer.Id
});
}
//update booking in the database
booking.Status = "Cancelled";
_context.Update(booking);
await _context.SaveChangesAsync();
//redirect to my bookings page
return(RedirectToAction(nameof(CustomerController.UserBookings), "Customer"));
}
public async Task <Charge> CreateChargeAsync(string customerId, string source, string destination, string description, decimal totalAmount, decimal applicationFeeAmount, Dictionary <string, string> metadata)
{
var options = new ChargeCreateOptions
{
Customer = customerId,
Source = source,
Description = description,
Amount = (long)(totalAmount * 100),
ApplicationFeeAmount = (long)(applicationFeeAmount * 100),
TransferData = new ChargeTransferDataOptions {
Destination = destination
},
Currency = "usd",
Capture = false,
Metadata = metadata
};
var service = new ChargeService();
return(await service.CreateAsync(options));
}
public async Task <IEnumerable <TransactionDTO> > Execute(PaymentModel payment)
{
var options = new ChargeCreateOptions
{
Amount = payment.Amount,
Currency = payment.Currency,
Source = payment.CardToken,
Capture = false,
};
var service = new ChargeService();
var transaction = await _retryHelper.RetryIfThrown(async() =>
{
var result = await service.CreateAsync(options);
return(_mappingProvider.GetMappingOperation(PaymentServiceConstants.PaymentMappingType.Stripe_Succeeded)
.Map(PaymentServiceConstants.PaymentType.Auth, payment, result, result.Created));
}, PaymentServiceConstants.PaymentType.Auth, payment, PaymentServiceConstants.isSucceeded.Succeeded);
return(await _paymentRepository.CreateTransactions(transaction));
}
public async Task PayAsync(string cardNo, int month, int year, string cvv, int totalPrice)
{
try
{
StripeConfiguration.ApiKey = "sk_test_51IWOzDGYDMIyeu07oFfINh8c6mroUIYKetZCHTkBmTbgEuZ1PvyF8rEvbFIfHueIc0OcjfeCFrEfrFqvr7g5BEVH00dtxFqW9C";
var optionstoken = new TokenCreateOptions
{
Card = new TokenCardOptions
{
Number = cardNo,
ExpMonth = month,
ExpYear = year,
Cvc = cvv,
}
};
var servicetoken = new TokenService();
Token stripetoken = await servicetoken.CreateAsync(optionstoken);
var options = new ChargeCreateOptions
{
Amount = totalPrice,
Currency = "lkr",
Description = "test",
Source = stripetoken.Id
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(options);
if (charge.Paid)
{
paymentStatus = true;
}
}
catch (Exception)
{
throw;//return e.Message;
}
}
public async Task PayAsync(string cardNo, int month, int year, string cvv, int totalPrice)
{
try
{
StripeConfiguration.ApiKey = "sk_test_51IqaYtLJAVJW1FAT9DgEKemTTU7JVLygtJqSCZ6jFGuRn0iwN8fECa19an6p8Dr0v4euF5ScXiJiVM3ZMvAYgwUI00aZIyHVxi";
var optionstoken = new TokenCreateOptions
{
Card = new TokenCardOptions
{
Number = cardNo,
ExpMonth = month,
ExpYear = year,
Cvc = cvv,
}
};
var servicetoken = new TokenService();
Token stripetoken = await servicetoken.CreateAsync(optionstoken);
var options = new ChargeCreateOptions
{
Amount = totalPrice,
Currency = "lkr",
Description = "test",
Source = stripetoken.Id
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(options);
if (charge.Paid)
{
paymentStatus = true;
}
}
catch (Exception)
{
throw;//return e.Message;
}
}
public async Task <StripeIdResponse> CreateCharge(string source, decimal amount, string description)
{
var chargeService = new ChargeService();
var charge = await chargeService.CreateAsync(new ChargeCreateOptions
{
SourceId = source,
Amount = ConvertToStripePrice(amount),
Description = description,
Currency = AbpZeroTemplateConsts.Currency,
Capture = true
});
if (!charge.Paid)
{
throw new UserFriendlyException(L("PaymentCouldNotCompleted"));
}
return(new StripeIdResponse
{
Id = charge.Id
});
}
public async Task <IActionResult> Charge(string stripeEmail, string stripeToken)
{
var customers = new CustomerService();
var charges = new ChargeService();
var cartTotal = _cart.GetCartTotalAsync().Result.ToString();
cartTotal += "00";
var customer = await customers.CreateAsync(new CustomerCreateOptions
{
Email = stripeEmail,
Source = stripeToken
});
if (cartTotal == "000")
{
return(RedirectToAction("EmptyCart"));
}
var charge = await charges.CreateAsync(new ChargeCreateOptions
{
Amount = Convert.ToInt64(cartTotal),
Description = "Test Payment",
Currency = "pln",
Customer = customer.Id,
ReceiptEmail = stripeEmail,
});
if (charge.Status == "succeeded")
{
return(View());
}
else
{
return(View());
}
}
private async Task <Charge> GetCharges(string stripeEmail, string stripeToken)
{
var customers = new CustomerService();
var charges = new ChargeService();
var customer = await customers.CreateAsync(new CustomerCreateOptions
{
Email = stripeEmail,
Source = stripeToken
});
var charge = await charges.CreateAsync(new ChargeCreateOptions
{
Amount = _paymentDetails.Amount * 100, //stripe takes amounts in cents, multiply by 100 to bring it to the right amount;
Description = "Payment to SparkAuto garage",
Currency = "usd",
Customer = customer.Id
});
return(charge);
}
public static async Task <dynamic> CreatePayement(string cardnumber, int month, int year, int value, string cvc)
{
StripeConfiguration.ApiKey = "sk_test_51H2knvH2NJeUpvbl9dHq36t8evGWp88N9eCa8pUGBS5J5HSrQ2NNeEpnCc1znVwgKojg8wSksQE5Ffz9zEzvkwNE00OSiQdQPB";
var optionsToken = new TokenCreateOptions
{
Card = new CreditCardOptions
{
Number = cardnumber,
ExpMonth = month,
ExpYear = year,
Cvc = cvc
}
};
var servicetoken = new TokenService();
Token stripetoken = await servicetoken.CreateAsync(optionsToken);
// `source` is obtained with Stripe.js; see https://stripe.com/docs/payments/accept-a-payment-charges#web-create-token
var options = new ChargeCreateOptions
{
Amount = value,
Currency = "usd",
Source = stripetoken.Id,
Description = "My First Test Charge (created for API docs)",
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(options);
if (charge.Paid)
{
return("success");
}
else
{
return("failed");
}
}
/*
* Charge a source here (only used for iDeal right now). It's a background job so it can be restarted.
*/
public async Task Charge(string sourceId)
{
logger.LogInformation("Processing chargeable");
Source source = await sourceService.GetAsync(sourceId).ConfigureAwait(false);
if (source.Status == StatusChargeable)
{
Charge charge;
try
{
charge = await chargeService.CreateAsync(new ChargeCreateOptions()
{
Amount = source.Amount,
Currency = source.Currency,
SourceId = sourceId,
CustomerId = source.Customer,
Description = "A donation to Stichting CollAction"
}).ConfigureAwait(false);
}
catch (StripeException e)
{
logger.LogError(e, "Error processing chargeable");
throw;
}
Customer customer = await customerService.GetAsync(source.Customer).ConfigureAwait(false);
ApplicationUser?user = customer != null ? await userManager.FindByEmailAsync(customer.Email).ConfigureAwait(false) : null;
context.DonationEventLog.Add(new DonationEventLog(userId: user?.Id, type: DonationEventType.Internal, eventData: charge.ToJson()));
await context.SaveChangesAsync().ConfigureAwait(false);
}
else
{
logger.LogError("Invalid chargeable received");
throw new InvalidOperationException($"source: {source.Id} is not chargeable, something went wrong in the payment flow");
}
}
public async Task <IActionResult> Charge(string stripeEmail, string stripeToken,
long amountInCents, string productName)
{
Random r = new Random();
var customerService = new CustomerService();
var chargeService = new ChargeService();
var dbCustomerId = r.Next(0, 10);
var customer = await customerService.CreateAsync(new CustomerCreateOptions
{
Email = stripeEmail,
SourceToken = stripeToken
});
var charge = await chargeService.CreateAsync(new ChargeCreateOptions
{
Amount = amountInCents,
Description = "Azure Functions Payment",
Currency = "usd",
CustomerId = customer.Id,
Metadata = new Dictionary <string, string> {
{ "id", dbCustomerId.ToString() },
{ "name", RandomNames[dbCustomerId] },
{ "product", productName }
}
});
var confirmation = new Confirmation()
{
ChargeId = charge.Id,
Email = customer.Email,
Product = productName
};
return(View(confirmation));
}
public async Task <bool> ProcessAsync(StripePaymentDto payment)
{
try
{
var optionsToken = new TokenCreateOptions()
{
Card = new CreditCardOptions
{
Number = payment.Number,
ExpYear = payment.ExpYear,
ExpMonth = payment.ExpMonth,
Cvc = payment.Cvc
}
};
var serviceToken = new TokenService();
var stripeToken = await serviceToken.CreateAsync(optionsToken);
var options = new ChargeCreateOptions
{
Amount = payment.Value,
Currency = payment.Currency,
Description = payment.Description,
Source = stripeToken.Id
};
var service = new ChargeService();
var charge = await service.CreateAsync(options);
return(charge.Paid);
}
catch (Exception e)
{
throw new PaymentException(e.Message);
}
}
public async Task <IActionResult> SummaryPost(string stripeToken)
//Stripe's Script pass string token
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
if (claim == null)
{
return(RedirectToAction(nameof(Index)));
}
OrderDetailsCart.OrderHeader.PaymentStatus = SD.Status.paymentPending;
OrderDetailsCart.OrderHeader.OrderDate = DateTime.Now;
OrderDetailsCart.OrderHeader.UserId = claim.Value;
OrderDetailsCart.OrderHeader.Status = SD.Status.paymentPending;
OrderDetailsCart.OrderHeader.PickupTime = Convert.ToDateTime(OrderDetailsCart.OrderHeader.PickupDate.ToShortDateString() + " " +
OrderDetailsCart.OrderHeader.PickupTime.TimeOfDay.ToString());
OrderDetailsCart.OrderHeader.OrderTotalOriginal = "0";
OrderDetailsCart.OrderHeader.OrderTotalDiscount = "0";
List <OrderDetails> orderDetailList = new List <OrderDetails>();
//We have to add OrderHeader ecouse order details need orderHedear.Id
await _db.OrderHeader.AddAsync(OrderDetailsCart.OrderHeader);
await _db.SaveChangesAsync();
OrderDetailsCart.ListCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId.ToString().Equals(claim.Value)).ToListAsync();
decimal orderTotalAcc = 0;
foreach (var list in OrderDetailsCart.ListCart)
{
list.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(m => m.Id.ToString().Equals(list.MenuItemId.ToString()));
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = list.MenuItemId,
OrderId = OrderDetailsCart.OrderHeader.Id,
Description = list.MenuItem.Description,
Name = list.MenuItem.Name,
Price = list.MenuItem.Price.ToString(),
Count = list.Count,
};
orderTotalAcc += (orderDetails.Count * decimal.Parse(orderDetails.Price));
await _db.OrderDetails.AddAsync(orderDetails);
//decimal orderTotal = decimal.Parse(OrderDetailsCart.OrderHeader.OrderTotalDiscount);
//orderTotal+=(decimal)(list.MenuItem.Price*list.Count);
//OrderDetailsCart.OrderHeader.OrderTotalDiscount = orderTotal.ToString();
}
OrderDetailsCart.OrderHeader.OrderTotalOriginal = orderTotalAcc.ToString();
OrderDetailsCart.OrderHeader.OrderTotalDiscount = OrderDetailsCart.OrderHeader.OrderTotalOriginal;
//OrderDetailsCart.OrderHeader.PickupName = appUser.FirstName + " " + appUser.LastName;
//OrderDetailsCart.OrderHeader.PhoneNumber = appUser.PhoneNumber;
//OrderDetailsCart.OrderHeader.PickupTime = DateTime.Now;
var couponCodeFormSession = HttpContext.Session.GetString(SD.SessionCouponCodeCookie);
if (couponCodeFormSession != null)
{
OrderDetailsCart.OrderHeader.CouponCode = couponCodeFormSession;
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower().Equals(couponCodeFormSession.ToLower())).FirstOrDefaultAsync();
OrderDetailsCart.OrderHeader.OrderTotalDiscount = SD.DicountedPrice(couponFromDb, decimal.Parse(OrderDetailsCart.OrderHeader.OrderTotalOriginal)).ToString();
}
OrderDetailsCart.OrderHeader.CouponCodeDiscount = (decimal.Parse(OrderDetailsCart.OrderHeader.OrderTotalOriginal) - decimal.Parse(OrderDetailsCart.OrderHeader.OrderTotalDiscount)).ToString();
await _db.SaveChangesAsync();
_db.ShoppingCart.RemoveRange(OrderDetailsCart.ListCart);
HttpContext.Session.SetInt32(SD.SessionCartCountCookie, 0);
await _db.SaveChangesAsync();
//stripe transaction part
var options = new ChargeCreateOptions
{
Amount = (long?)(decimal.Parse(OrderDetailsCart.OrderHeader.OrderTotalDiscount) * 100),
Currency = SD.TransactionCurrency,
Description = "Order ID : " + OrderDetailsCart.OrderHeader.Id.ToString(),
Source = stripeToken
};
var service = new ChargeService();
//start transaction
Charge charge = await service.CreateAsync(options);
if (charge.BalanceTransactionId == null)
{
OrderDetailsCart.OrderHeader.PaymentStatus = SD.Status.paymentRejected;
}
else
{
OrderDetailsCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == SD.TransactionSucceeded)
{
OrderDetailsCart.OrderHeader.PaymentStatus = SD.Status.paymentApproved;
OrderDetailsCart.OrderHeader.Status = SD.Status.orderSubmitted;
//email for succesful SD.CompanyInformations; for fancy email write here html
var emailFromDb = (await _db.Users.Where(u => u.Id.Equals(claim.Value)).FirstOrDefaultAsync()).Email;
await _emailSender.SendEmailAsync(
emailFromDb,
SD.CompanyInformations.emailSubject + OrderDetailsCart.OrderHeader.Id.ToString(),
SD.CompanyInformations.emailMessageOrderSubmitedSuccess
);
}
else
{
OrderDetailsCart.OrderHeader.PaymentStatus = SD.Status.paymentRejected;
}
await _db.SaveChangesAsync();
//return RedirectToAction("Index","Home");
return(RedirectToAction("Confirm", "Order", new { id = OrderDetailsCart.OrderHeader.Id }));
}
private async Task PostIDealProcessPayment(PostProcessPaymentRequest postProcessPaymentRequest, string bank)
{
var secretKey = _stripePaymentSettings.SecretKey;
var clientSecret = _httpContextAccessor.HttpContext.Request.Query["client_secret"].ToString();
string source;
if (string.IsNullOrWhiteSpace(clientSecret))
{
if (!string.IsNullOrWhiteSpace(secretKey))
{
//get store location
var storeLocation = _webHelper.GetStoreLocation();
StripeConfiguration.ApiKey = secretKey;
if (!string.IsNullOrWhiteSpace(postProcessPaymentRequest.Order.CustomValuesXml))
{
var options = new SourceCreateOptions()
{
Amount = (long)postProcessPaymentRequest.Order.OrderTotal,
Currency = postProcessPaymentRequest.Order.CustomerCurrencyCode.ToLower(),
Type = SourceType.Ideal,
Redirect = new SourceRedirectOptions {
ReturnUrl = $"{storeLocation}checkout/OpcCompleteRedirectionPayment",
},
Ideal = new SourceIdealCreateOptions {
Bank = bank
}
};
var service = new SourceService();
Source charge = await service.CreateAsync(options);
if (charge.StripeResponse.StatusCode == System.Net.HttpStatusCode.OK)
{
var jObject = JObject.Parse(charge.StripeResponse.Content);
string value = (string)jObject.SelectToken("redirect.url");
source = (string)jObject.SelectToken("id");
_httpContextAccessor.HttpContext.Session.SetString("source", source);
_httpContextAccessor.HttpContext.Response.Redirect(value);
}
}
}
else
{
await Task.FromException(new Exception("secret key canot be null or empty"));
}
}
else
{
source = _httpContextAccessor.HttpContext.Session.GetString("source");
var options = new ChargeCreateOptions {
Amount = (long)postProcessPaymentRequest.Order.OrderTotal,
Currency = postProcessPaymentRequest.Order.CustomerCurrencyCode.ToLower(),
Source = source,
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(options);
if (charge.StripeResponse.StatusCode == System.Net.HttpStatusCode.OK)
{
postProcessPaymentRequest.Order.PaymentStatus = PaymentStatus.Paid;
_httpContextAccessor.HttpContext.Session.Remove("source");
}
}
}
/// <summary>
/// Make Payment
/// </summary>
/// <param name="form"></param>
/// <returns></returns>
public async Task <ActionResult> MakePayment(FormCollection form)
{
HttpClient client = new HttpClient();
string date = form["expiration"];
int month = int.Parse(date.Substring(5));
int year = int.Parse(date.Substring(0, 4));
string amount = form["payment_amount"];
string paymentAmount = (double.Parse(amount) * 100).ToString();
long amt = long.Parse(paymentAmount);
try
{
StripeConfiguration.ApiKey = "sk_test_51INLgeIR2cxnZNWwi0AHsRoFifYouOH6QcLsIxEEOmBwXNyXXXX4Jt2MOHbR6d5KKMotvMYyrKa1AtrBpcc8q8IB009h5ew7Iw";
var optionstoken = new TokenCreateOptions
{
Card = new TokenCardOptions
{
Number = form["card_number"],
ExpMonth = month,
ExpYear = year,
Cvc = form["cvc"]
}
};
var servicetoken = new TokenService();
Token stripetoken = await servicetoken.CreateAsync(optionstoken);
var options = new ChargeCreateOptions
{
Amount = amt,
Currency = "usd",
Description = "Payment from " + Name.last_name + ", " + Name.first_name,
Source = stripetoken.Id
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(options);
if (charge.Paid)
{
//update database
Payment p = new Payment();
p.payment_amount = decimal.Parse(amount);
p.user_id = Name.user_id;
p.payment_date = DateTime.Now;
gds.Payments.Add(p);
gds.SaveChanges();
return(Balance());
}
else
{
return(View("PaymentInfoView"));
}
}
catch (Exception ex)
{
throw;
}
}
public async Task <Tuple <bool, object> > Order(OrderRM orderRM, string userName)
{
Random random = new Random();
var items = new List <ItemsRM>();
//PaymentTypeId 3 is pay by cash
if (orderRM.PaymentTypeId != 3)
{
StripeConfiguration.ApiKey = _config["Stripe_SecretKey"];
var optionsToken = new TokenCreateOptions
{
Card = new CreditCardOptions
{
Number = orderRM.CardNumber,
ExpMonth = orderRM.Month,
ExpYear = orderRM.Year,
Cvc = orderRM.Cvc
}
};
if (optionsToken == null)
{
return(new Tuple <bool, object>(false, "Payment cannot be completed"));
}
var serviceToken = new TokenService();
Token stripeToken = await serviceToken.CreateAsync(optionsToken);
if (stripeToken == null)
{
return(new Tuple <bool, object>(false, "Payment cannot be completed"));
}
var options = new ChargeCreateOptions
{
Amount = orderRM.Amount * 100,
Currency = "usd",
Source = stripeToken.Id,
Description = $"Success final project payment by {userName}"
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(options);
if (!charge.Paid)
{
return(new Tuple <bool, object>(false, "Payment cannot be completed"));
}
}
var customerId = _context.CustomerInfo.Where(c => c.UsersEmail == userName).FirstOrDefault().CustomerId;
var order = new Orders
{
CustomerId = customerId,
OrderTotal = orderRM.Amount,
PaymentTypeId = orderRM.PaymentTypeId,
};
var randomId = random.Next(10000);
while (_context.Orders.Any(id => id.OrderId == randomId))
{
randomId = random.Next(10000);
}
order.OrderId = randomId;
_context.Orders.Add(order);
foreach (ItemsRM item in orderRM.itemsRM)
{
var StoreItem = new SelectedItem {
OrderId = randomId, MenuItemId = item.Item.MenuItemId, Quantity = item.qty
};
items.Add(item);
_context.SelectedItem.Add(StoreItem);
}
await _context.SaveChangesAsync();
var returnOrder = new OrderCompleteRM
{
OrderId = order.OrderId,
Customer = userName,
ItemsRM = items,
OrderTotal = order.OrderTotal,
PaymentTypeId = order.PaymentTypeId
};
return(new Tuple <bool, object>(true, returnOrder));
}
public async Task HandleSourceChargeable(Source source)
{
var steamId = ulong.Parse(source.Metadata["steamId"]);
var payerSteamId = ulong.Parse(source.Metadata["payerSteamId"]);
var matchId = long.Parse(source.Metadata["matchId"]);
try
{
var player = await _context.Players.FindAsync(steamId);
if (player == null)
{
player = new Player {
SteamId = steamId
};
_context.Players.Add(player);
await _context.SaveChangesAsync();
}
var paymentKind = (PaymentKind)Enum.Parse(typeof(PaymentKind), source.Metadata["paymentKind"]);
ValidatePaymentKind(player, paymentKind);
player.PatreonEndDate = DateTime.UtcNow.AddDays(30);
player.PatreonLevel = paymentKind switch
{
PaymentKind.Purchase1 => 1,
PaymentKind.Purchase2 => 2,
PaymentKind.UpgradeTo2 => 2,
_ => throw new NotImplementedException(),
};
var charge = await _chargeService.CreateAsync(new ChargeCreateOptions
{
Amount = source.Amount,
Currency = source.Currency,
Source = source.Id,
});
if (charge.Status != "succeeded")
{
// TODO: Throw?
_logger.LogCritical($"Charge {charge.Id} of source {source.Id} has invalid initial status {charge.Status}");
}
_context.MatchEvents.Add(new MatchEvent()
{
MatchId = matchId,
Body = new PaymentUpdateMatchEventBody()
{
SteamId = steamId.ToString(),
PayerSteamId = payerSteamId.ToString(),
Level = player.PatreonLevel,
EndDate = player.PatreonEndDate,
}
});
await _context.SaveChangesAsync();
_logger.LogCritical($"Charge for user '{steamId}' is complete!");
}
catch (Exception ex)
{
_context.MatchEvents.Add(new MatchEvent()
{
MatchId = matchId,
Body = new PaymentUpdateMatchEventBody()
{
SteamId = steamId.ToString(),
PayerSteamId = payerSteamId.ToString(),
Error = ex.Message,
}
});
_logger.LogCritical($"Charge for user '{steamId}' failed: {ex.Message}");
await _context.SaveChangesAsync();
}
}
public async Task <IActionResult> SummaryPost(string stripeEmail, string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)this.User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
var applicationUser = await userService.GetUserById(claim.Value);
DetailsCart.listCart = (await shoppingCartService.GetShoppingCartsByUserId(claim.Value)).ToList();
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
DetailsCart.OrderHeader.Status = SD.PaymentStatusPending;
DetailsCart.OrderHeader.UserId = claim.Value;
DetailsCart.OrderHeader.PickUpTime =
Convert.ToDateTime(DetailsCart.OrderHeader.PickUpDate.ToShortDateString()
+ " " + DetailsCart.OrderHeader.PickUpTime.ToShortTimeString());
DetailsCart.OrderHeader.OrderDate = DateTime.Now;
await orderService.AddOrderHeaderAsync(DetailsCart.OrderHeader);
DetailsCart.OrderHeader.OrderTotalOriginal = 0;
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
foreach (var item in DetailsCart.listCart)
{
item.MenuItem = await menuItemService.GetMenuItemById(item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = DetailsCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
DetailsCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
orderDetailsList.Add(orderDetails);
}
await orderService.AddOrdersDetailsAsync(orderDetailsList);
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
DetailsCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await couponService.GetCouponByName(DetailsCart.OrderHeader.CouponCode.ToLower());
DetailsCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, DetailsCart.OrderHeader.OrderTotalOriginal);
}
else
{
DetailsCart.OrderHeader.OrderTotal = DetailsCart.OrderHeader.OrderTotalOriginal;
}
DetailsCart.OrderHeader.CouponCodeDiscount = DetailsCart.OrderHeader.OrderTotalOriginal - DetailsCart.OrderHeader.OrderTotal;
await orderService.CommitAsync();
await shoppingCartService.RemoveShoppingCarts(DetailsCart.listCart);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
var options = new ChargeCreateOptions()
{
Amount = Convert.ToInt32(DetailsCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order Id : " + DetailsCart.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(options);
if (charge.BalanceTransactionId == null)
{
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
DetailsCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
var subject = "Spicy - Order Created " + DetailsCart.OrderHeader.Id.ToString();
var msg = "The Order Has been created successfully";
await emailSender.SendEmailAsync(applicationUser.Email, subject, msg);
//emailSender.SendMailkit(applicationUser.Name,applicationUser.Email);
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
DetailsCart.OrderHeader.Status = SD.StatusSubmitted;
await orderService.CommitAsync();
}
else
{
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
await orderService.CommitAsync();
}
return(RedirectToAction("Confirm", "Order", new { id = DetailsCart.OrderHeader.Id }));
//return RedirectToAction("Index", "Home");
}
public async Task <Uplata> CreateCharge(ClanUplataRequestModel Podaci, int ClanId)
{
//var IdTrenutnog = _HttpContext.HttpContext.User.Claims;
Uplata novaUplata;
UplataClan clanUplata;
try
{
StripeConfiguration.ApiKey = "sk_test_51IFliGAyuqhKSgYjdeKEYXUGcz2U8KAkBKySevIgXCl7aSGjUzsLTobfEe0VSyzSopOgo3rKwCI1a0R3ylEyjkwY00cXquMxaz";
var optionsToken = new TokenCreateOptions
{
Card = new TokenCardOptions
{
Number = Podaci.BrojKartice,
ExpMonth = Podaci.DatumIsteka.Month,
ExpYear = Podaci.DatumIsteka.Year,
Cvc = Podaci.CCV
}
};
var tokenService = new TokenService();
Token stripeToken = await tokenService.CreateAsync(optionsToken);
var optionsCharge = new ChargeCreateOptions
{
Amount = Podaci.IznosUplate,
Currency = "bam",
Description = $"Uplata za mjesec {DateTime.Now.Month}",
Source = stripeToken.Id
};
var serviceCharge = new ChargeService();
Charge Charge = await serviceCharge.CreateAsync(optionsCharge);
if (Charge.Paid == true)
{
novaUplata = new Uplata
{
Id = Charge.Id,
BrojKartice = Podaci.BrojKartice,
CCV = Podaci.CCV,
ClanId = ClanId,
DatumIstekaKartice = Podaci.DatumIsteka,
DatumUplate = DateTime.Now,
Email = Podaci.Email,
Ime = Podaci.Ime,
Prezime = Podaci.Prezime,
UplaćeniIznos = Podaci.IznosUplate / _NUMBER_FOR_CONVERTING_AMOUNTH_BETWEEN_STRIPE_AND_REAL
};
clanUplata = new UplataClan
{
UplataClanaId = novaUplata.Id,
ClanId = novaUplata.ClanId,
GodinaUplate = novaUplata.DatumUplate.Year,
MjesecUplate = novaUplata.DatumUplate.Month,
DanUplate = novaUplata.DatumUplate.Day
};
_Context.Uplate.Add(novaUplata);
_Context.UplateClanova.Add(clanUplata);
await _Context.SaveChangesAsync();
return(novaUplata);
}
else
{
throw new Exception(Charge.FailureCode);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
//public IActionResult IspisiPoruku()
//{
// return View("Plati");
//}
public async Task <IActionResult> Plati(RacunVM x)
{
var KorisnikID = _dbContext.RezervacijaKorisnici.FirstOrDefault(a => a.RezervacijaID == x.RezervacijaID).KorisnikID;
Racun novi = new Racun()
{
IznosRacuna = x.UkupanIznos
};
_dbContext.Add(novi);
_dbContext.SaveChanges();
if (x.nacinPlacanjaID == 1)
{
try
{
StripeConfiguration.ApiKey = "sk_test_51IYDuMFF8QkBScNHXFHqiScdbz9rVOVrTC1qcBGfOAa9PcpJnyOu2vo4dwDGKwTyjsPqXV2R5xNHOZATHyDn6xMl001rwGzwGG";
var optionsToken = new TokenCreateOptions
{
Card = new CreditCardOptions
{
Number = x.KreditnaKarticaBroj,
ExpMonth = x.MjesecIstekaKartice,
ExpYear = x.GodinaIstekaKartice,
Cvc = x.CVC
}
};
var serviceToken = new TokenService();
Token stripeToken = await serviceToken.CreateAsync(optionsToken);
var options = new ChargeCreateOptions
{
Amount = (int)x.UkupanIznos,
Currency = "usd",
Description = "test",
Source = stripeToken.Id
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(options);
if (charge.Paid)
{
var ima = _dbContext.KreditnaKartica.Where(d => d.KorisnikID == KorisnikID && d.BrojKreditneKartice == x.KreditnaKarticaBroj).FirstOrDefault();
if (ima == null)
{
var kartica = new KreditnaKartica()
{
BrojKreditneKartice = x.KreditnaKarticaBroj,
CVC = x.CVC,
MjesecIstekaKartice = x.MjesecIstekaKartice,
GodinaIstekaKartice = x.GodinaIstekaKartice,
KorisnikID = KorisnikID
};
_dbContext.Add(kartica);
_dbContext.SaveChanges();
novi.KreditnaKarticaID = kartica.KreditnaKarticaID;
_dbContext.SaveChanges();
}
}
}
catch (Exception ex)
{
throw ex;
}
}
var rezervacija = _dbContext.Rezervacije.FirstOrDefault(a => a.RezervacijaID == x.RezervacijaID);
rezervacija.RacunID = novi.RacunID;
rezervacija.NacinPlacanjaID = x.nacinPlacanjaID;
rezervacija.DatumVjencanja = x.dtmDate;
rezervacija.StatusRezervacijeID = 1;
_dbContext.SaveChanges();
return(View("Plati"));
}
public async Task <IActionResult> SummaryPOST(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)this.User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
this.DetailCart.ListCart = await this.db.ShoppingCart
.Where(c => c.ApplicationUserId == claim.Value)
.ToListAsync();
this.DetailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
this.DetailCart.OrderHeader.OrderDate = DateTime.Now;
this.DetailCart.OrderHeader.UserId = claim.Value;
this.DetailCart.OrderHeader.Status = SD.PaymentStatusPending;
this.DetailCart.OrderHeader.PickupTime = Convert.ToDateTime(
this.DetailCart.OrderHeader.PickupDate.ToShortDateString() + " " + this.DetailCart.OrderHeader.PickupTime.ToShortTimeString());
this.db.OrderHeader.Add(this.DetailCart.OrderHeader);
await this.db.SaveChangesAsync();
this.DetailCart.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in this.DetailCart.ListCart)
{
item.MenuItem = await this.db.MenuItem.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
var orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = this.DetailCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
this.DetailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
this.db.OrderDetails.Add(orderDetails);
}
var couponCode = this.HttpContext.Session.GetString(SD.ssCouponCode);
if (!string.IsNullOrWhiteSpace(couponCode))
{
this.DetailCart.OrderHeader.CouponCode = couponCode;
var couponFromDb = await this.db.Coupon
.FirstOrDefaultAsync(c => c.Name.ToUpper() == this.DetailCart.OrderHeader.CouponCode.ToUpper());
this.DetailCart.OrderHeader.OrderTotal =
SD.DiscountedPrice(couponFromDb, this.DetailCart.OrderHeader.OrderTotalOriginal);
}
else
{
this.DetailCart.OrderHeader.OrderTotal = this.DetailCart.OrderHeader.OrderTotalOriginal;
}
this.DetailCart.OrderHeader.CouponCodeDiscount =
this.DetailCart.OrderHeader.OrderTotalOriginal - this.DetailCart.OrderHeader.OrderTotal;
this.db.ShoppingCart.RemoveRange(this.DetailCart.ListCart);
this.HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
await this.db.SaveChangesAsync();
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(this.DetailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + this.DetailCart.OrderHeader.Id,
SourceId = stripeToken
};
var service = new ChargeService();
var charge = await service.CreateAsync(options);
if (charge.BalanceTransactionId == null)
{
this.DetailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
this.DetailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
await this.emailSender.SendEmailAsync(
(await this.db.Users.FirstOrDefaultAsync(u => u.Id == claim.Value)).Email,
$"Spice - Order created {this.DetailCart.OrderHeader.Id.ToString()}",
"Order has been submitted successfully!");
this.DetailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
this.DetailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
this.DetailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
await this.db.SaveChangesAsync();
//return this.RedirectToAction("Index", "Home");
return(this.RedirectToAction("Confirm", "Order", new { id = this.DetailCart.OrderHeader.Id }));
}
public async Task <Charge> CreateChargeAsync(ChargeCreateOptions chargeCreateOptions, RequestOptions requestOptions = null, CancellationToken cancellationToken = default)
{
return(await chargeService.CreateAsync(chargeCreateOptions, requestOptions, cancellationToken));
}
/// <summary>
/// Process a stripe payment
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <StripeResponse> ProcessStripePaymentAsync(StripeRequest request)
{
// Set your secret key: remember to change this to your live secret key in production
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.SetApiKey(options.ApiKey);
//create new charge
//todo:configure application costs
var chargeOptions = new ChargeCreateOptions
{
Amount = request.Amount,
Currency = "usd",
SourceId = request.Token,
ReceiptEmail = request.Email,
Metadata = request.Metadata,
//immediately capture the charge
Capture = true,
Description = "",//todo:charge description that can be added to the web interface
};
//create a charge
var service = new ChargeService();
Charge charge;
StripeResponse response = new StripeResponse();
//stripe api errors
try
{
// Use Stripe's library to make request
//todo:check out for outcome
charge = await service.CreateAsync(chargeOptions);
//return response
response.success = true;
response.Metadata = charge.Metadata;
response.ChargeId = charge.Id;
response.CreatedAt = charge.Created;
return(response);
}
catch (StripeException e)
{
switch (e.StripeError.ErrorType)
{
case ErrorCodes.CardError:
response.ErrorModel = new ErrorModel
{
ErrorCode = ErrorCodes.CardError,
ErrorAction = e.StripeError.Code,
ErrorDescription = e.StripeError.Message
};
break;
case ErrorCodes.ApiConnectionError:
response.ErrorModel = new ErrorModel
{
ErrorCode = ErrorCodes.ApiConnectionError,
ErrorDescription = "Network Error Please retry again."
};
break;
case ErrorCodes.ApiError:
response.ErrorModel = new ErrorModel
{
ErrorCode = ErrorCodes.ApiError,
ErrorAction = e.StripeError.Code,
ErrorDescription = "Network Error Please retry again."
};
break;
case ErrorCodes.AuthenticationError:
response.ErrorModel = new ErrorModel
{
ErrorCode = ErrorCodes.AuthenticationError,
ErrorDescription = "A wrong api key was supplied."
};
break;
case ErrorCodes.InvalidRequestError:
response.ErrorModel = new ErrorModel
{
ErrorCode = ErrorCodes.InvalidRequestError,
ErrorDescription = "Bad request, check supplied parameters."
};
break;
case ErrorCodes.RateLimitError:
response.ErrorModel = new ErrorModel
{
ErrorCode = ErrorCodes.RateLimitError,
ErrorDescription = "Too many requests."
};
break;
case ErrorCodes.IdempotencyError:
response.ErrorModel = new ErrorModel
{
ErrorCode = ErrorCodes.IdempotencyError,
ErrorDescription = "Duplicate idempotency key."
};
break;
default:
// Unknown Error Type
break;
}
return(response);
}
}
public async Task <bool> MakePaymentWithCard(Guid storeId, double total, Guid paymentCardId, string orderId)
{
try
{
var paymentCard = _context.PaymentCards.Where(pc => pc.PaymentCardId == paymentCardId).FirstOrDefault();
var key = await _context.Stores.Where(s => s.StoreId == storeId).FirstOrDefaultAsync();
StripeConfiguration.ApiKey = key.SKKey;
string valuetotal = total.ToString("0.00").Replace(".", "");
var tokenoptions = new TokenCreateOptions()
{
Card = new CreditCardOptions()
{
Number = paymentCard.CardNumber,
ExpYear = long.Parse(paymentCard.Year),
ExpMonth = long.Parse(paymentCard.Month),
Cvc = paymentCard.Cvc,
Name = paymentCard.HolderName,
},
};
var tokenService = new TokenService();
var stripeToken = await tokenService.CreateAsync(tokenoptions);
var chargeoptions = new Stripe.ChargeCreateOptions
{
Amount = long.Parse(valuetotal),
Currency = "USD",
ReceiptEmail = "*****@*****.**",
StatementDescriptor = "Order Id:" + orderId.Substring(0, 8),
Capture = true,
Source = stripeToken.Id,
Description = "Payment of Order " + orderId,
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(chargeoptions);
if (charge.Status == "succeeded")
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(false);
}
}
