public IActionResult SummaryPOST(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
//initialize object
ShoppingCartVM.OrderHeader.ApplicationUser = _unitOfWork.ApplicationUser.GetFirstOrDefault
(x => x.Id == claim.Value, includeProperties: "Company");
ShoppingCartVM.ListCart = _unitOfWork.ShoppingCart.GetAll
(x => x.ApplicationUserId == claim.Value, includeProperties: "Product");
//initialize status
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusPending;
ShoppingCartVM.OrderHeader.ApplicationUserId = claim.Value;
ShoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
_unitOfWork.OrderHeader.Add(ShoppingCartVM.OrderHeader);
_unitOfWork.Save();
foreach (var item in ShoppingCartVM.ListCart)
{
item.Price = SD.GetPriceBasedOnQuantity(item.Count, item.Product.Price, item.Product.Price50, item.Product.Price100);
OrderDetails orderDetails = new OrderDetails()
{
ProductId = item.ProductId,
OrderId = ShoppingCartVM.OrderHeader.Id,
Price = item.Price,
Count = item.Count
};
ShoppingCartVM.OrderHeader.OrderTotal += (orderDetails.Price * orderDetails.Count);
_unitOfWork.OrderDetails.Add(orderDetails);
}
;
//remove all list of shopping cart
_unitOfWork.ShoppingCart.RemoveRange(ShoppingCartVM.ListCart);
_unitOfWork.Save();
HttpContext.Session.SetInt32(SD.ssShoppingCart, 0);
if (stripeToken == null)
{
//order will be created for delayed payment for auth company
ShoppingCartVM.OrderHeader.PaymentDueDate = DateTime.Now.AddDays(30);
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusDelayedPayment;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
}
else
{
//process the payment
var options = new ChargeCreateOptions()
{
Amount = Convert.ToInt32(ShoppingCartVM.OrderHeader.OrderTotal * 100),//in cent
Currency = "usd",
Description = $"Order ID: {ShoppingCartVM.OrderHeader.Id}",
Source = stripeToken
};
//create charge service
var service = new ChargeService();
Charge charge = service.Create(options);
//check for balance in acc
if (charge.BalanceTransactionId == null)
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
ShoppingCartVM.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
//check for charge status
if (charge.Status.ToLower() == "succeeded")
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
ShoppingCartVM.OrderHeader.PaymentDate = DateTime.Now;
}
}
_unitOfWork.Save();
return(RedirectToAction(nameof(OrderConfirmation), "Cart", new { id = ShoppingCartVM.OrderHeader.Id }));
}
public async Task <IActionResult> OnPostAsync(string stripeToken)
{
ShoppingCartVM.Order.PaymentStatus = SD.PaymentStatus.APPROVED;
ShoppingCartVM.Order.OrderStatus = SD.OrderStatus.APPROVED;
ShoppingCartVM.Order.OrderDate = DateTime.Now;
ShoppingCartVM.CartItems = await _cartService.GetAll(ShoppingCartVM.Order.UserId);
ShoppingCartVM.Order.OrderTotal = CalculateSum(ShoppingCartVM.CartItems);
if (ModelState.IsValid)
{
try
{
if (stripeToken != null)
{
Models.Order newOrder = await _orderService.Create(ShoppingCartVM);
if (newOrder == null)
{
throw new Exception("Order creation failed");
}
HttpContext.Session.SetInt32(SD.CART_SESSION_KEY, 0);
var chargeOptions = new ChargeCreateOptions
{
Amount = Convert.ToInt32(newOrder.OrderTotal * 100),
Currency = "MYR",
Description = $"E-Mall Order No. {newOrder.Id}",
Source = stripeToken
};
var chargeService = new ChargeService();
Charge charge = chargeService.Create(chargeOptions);
if (charge.Id == null)
{
newOrder.PaymentStatus = SD.PaymentStatus.REJECTED;
}
else
{
newOrder.TransactionId = charge.Id;
}
if (charge.Status.ToLower() == SD.StripeChargeStatus.SUCCEEDED)
{
newOrder.PaymentStatus = SD.PaymentStatus.APPROVED;
newOrder.OrderStatus = SD.OrderStatus.APPROVED;
newOrder.PaymentDate = DateTime.Now;
}
await _orderService.Update(newOrder);
SuccessMessage = "Thank you! Your order has been placed successfully!";
}
}
catch
{
ErrorMessage = "There is an error placing your order. Please try again later.";
}
}
else
{
ErrorMessage = "The information provided is not valid.";
}
return(RedirectToPage());
}
public IActionResult SummaryPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var id = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier).Value;
ShoppingCartVM.OrderHeader.ApplicationUser = _unitOfWork.ApplicationUser.GetFirstOrDefault(x => x.Id == id, includeProperties: "Company");
ShoppingCartVM.ListCart = _unitOfWork.ShoppingCart.GetAll(x => x.ApplicationUserId == id, includeProperties: "Product");
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
ShoppingCartVM.OrderHeader.OrderStatus = SD.OrderStatusPending;
ShoppingCartVM.OrderHeader.ApplicationUserId = id;
ShoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
_unitOfWork.OrderHeader.Add(ShoppingCartVM.OrderHeader);
_unitOfWork.Save();
foreach (var item in ShoppingCartVM.ListCart)
{
item.Price = SD.GetPriceBasedOnQuantity(item.Count, item.Product.Price,
item.Product.Price50, item.Product.Price100);
OrderDetails orderDetails = new OrderDetails()
{
ProductId = item.ProductId,
OrderId = ShoppingCartVM.OrderHeader.Id,
Price = item.Price,
Count = item.Count
};
ShoppingCartVM.OrderHeader.OrderTotal += orderDetails.Count * orderDetails.Price;
_unitOfWork.OrderDetails.Add(orderDetails);
}
_unitOfWork.ShoppingCart.RemoveRange(ShoppingCartVM.ListCart);
HttpContext.Session.SetInt32(SD.ShoppingCartSession, 0);
_unitOfWork.Save();
if (stripeToken == null) // Authorized user is placing order -> delayed payment
{
ShoppingCartVM.OrderHeader.PaymentDueDate = DateTime.Now.AddDays(30);
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusDelayedPayment;
ShoppingCartVM.OrderHeader.OrderStatus = SD.OrderStatusApproved;
}
else
{
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(ShoppingCartVM.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + ShoppingCartVM.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.Id == null)
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
ShoppingCartVM.OrderHeader.TransactionId = charge.Id;
}
if (charge.Status.ToLower() == "succeeded")
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
ShoppingCartVM.OrderHeader.OrderStatus = SD.OrderStatusApproved;
ShoppingCartVM.OrderHeader.PaymentDate = DateTime.Now;
}
}
_unitOfWork.Save();
return(RedirectToAction("OrderConfirmation", "Cart", new { id = ShoppingCartVM.OrderHeader.Id }));
}
public async Task <IActionResult> OnPostAsync()
{
// Pizza builder
if (!ModelState.IsValid)
{
return(Page());
}
pizzaOrder.IsComplete = false;
_context.PizzaOrders.Add(pizzaOrder);
await _context.SaveChangesAsync();
// Stripe create charge
var chargeOptions = new ChargeCreateOptions
{
Amount = pizzaOrder.Cost,
Currency = "usd",
Source = "tok_visa",
};
// Only assign shipping details to a charge object if delivery is selected
if (pizzaOrder.IsDelivery == true)
{
var shippingOptions = new ChargeShippingOptions
{
Name = shippingAddress.FirstName + " " + shippingAddress.LastName,
Address = new AddressOptions()
{
Line1 = shippingAddress.Line1,
City = shippingAddress.City,
State = shippingAddress.State,
PostalCode = shippingAddress.PostalCode.ToString()
}
};
chargeOptions.Shipping = shippingOptions;
}
var service = new ChargeService();
TempData["OrderSize"] = pizzaOrder.Size;
TempData["OrderQuantity"] = pizzaOrder.Quantity;
TempData["OrderToppings"] = pizzaOrder.Toppings;
// Divide by 100 for TempData to make the cost more viewable without bringing in any
// JavaScript to format for us on the page. We only need the cost to be without a decimal
// when communicating with Stripe
TempData["OrderCost"] = pizzaOrder.Cost / 100;
if (pizzaOrder.IsDelivery == true)
{
TempData["OrderRetrieval"] = "Your order will arrive in 30 minutes or less!";
}
else
{
TempData["OrderRetrieval"] = "Your order will be ready for pickup in 15 minutes";
}
Charge charge = service.Create(chargeOptions);
return(RedirectToPage("./OrderConfirmation"));
}
public IActionResult SummaryPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
ShoppingCartVM.OrderHeader.ApplicationUser = _unitOfWork.ApplicationUser
.GetFirstOrDefault(c => c.Id == ShoppingCartVM.OrderHeader.ApplicationUserId,
includeProperties: "Company");
ShoppingCartVM.ListCart = _unitOfWork.ShoppingCart
.GetAll(c => c.ApplicationUserId == claim.Value,
includeProperties: "Product");
ShoppingCartVM.OrderHeader.ApplicationUser = _context.ApplicationUsers.FirstOrDefault(c => c.Id == ShoppingCartVM.OrderHeader.ApplicationUserId);
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusPending;
ShoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
_unitOfWork.OrderHeader.save(ShoppingCartVM.OrderHeader);
_unitOfWork.Save();
foreach (var item in ShoppingCartVM.ListCart)
{
item.Price = SD.GetPriceBasedOnQuantity(item.Count, item.Product.Price,
item.Product.Price50, item.Product.Price100);
item.ApplicationUserId = ShoppingCartVM.OrderHeader.ApplicationUserId;
OrderDetails orderDetails = new OrderDetails()
{
ProductId = item.ProductId,
OrderId = ShoppingCartVM.OrderHeader.Id,
Price = item.Price,
Count = item.Count,
SweetenerId = item.SweetenerId,
SweetnessId = item.SweetnessId,
IceCubeId = item.IceCubeId,
MilkTypeId = item.MilkTypeId,
OriginId = item.OriginId,
ToppingId = item.ToppingId
};
ShoppingCartVM.OrderHeader.OrderTotal += orderDetails.Count * orderDetails.Price;
_unitOfWork.OrderDetails.Add(orderDetails);
}
_unitOfWork.ShoppingCart.RemoveRange(ShoppingCartVM.ListCart);
_unitOfWork.Save();
HttpContext.Session.SetInt32(SD.ssShoppingCart, 0);
if (stripeToken == null)
{
//order will be created for delayed payment for authroized company
ShoppingCartVM.OrderHeader.PaymentDueDate = DateTime.Now;
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusDelayedPayment;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
}
else
{
//process the payment
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(ShoppingCartVM.OrderHeader.OrderTotal * 100),
Currency = "eur",
Description = "Αριθμός Παραγγελίας : " + ShoppingCartVM.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.Id == null)
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
ShoppingCartVM.OrderHeader.TransactionId = charge.Id;
}
if (charge.Status.ToLower() == "succeeded")
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
ShoppingCartVM.OrderHeader.PaymentDate = DateTime.Now;
}
}
_unitOfWork.Save();
return(RedirectToAction("OrderConfirmation", "Cart", new { id = ShoppingCartVM.OrderHeader.Id }));
}
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 async Task <IActionResult> OnPostAsync([FromForm] string stripeToken)
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
UserEmail = user.Email;
StripeCustomerId = user.CustomerIdentifier;
var nullCustomerId = string.IsNullOrEmpty(StripeCustomerId);
var planId = Input.PlanId;
var planAmount = GetPlanPrice(planId);
var customerService = new CustomerService();
Customer customerLookup = new Customer();
if (!nullCustomerId)
{
customerLookup = customerService.Get(StripeCustomerId);
}
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
//Create new customer if doesnt exist
if (nullCustomerId || customerLookup.Deleted == true)
{
var customers = new CustomerService();
var customer = customers.Create(new CustomerCreateOptions
{
Email = UserEmail,
Plan = planId,
Description = UserEmail + " " + "[" + user.Id + "]"
});
user.CustomerIdentifier = customer.Id;
StripeCustomerId = user.CustomerIdentifier;
}
else
{
var subcriptionService = new SubscriptionService();
var subscriptionItems = new List <SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Plan = planId
}
};
var stripeSubscription = subcriptionService.Create(new SubscriptionCreateOptions
{
Customer = StripeCustomerId,
Items = subscriptionItems
});
}
Charge charge = new Charge();
if (planAmount > 0)
{
var chargeOptions = new ChargeCreateOptions
{
Amount = planAmount,
Currency = "usd",
Description = "RazorStripe for" + " " + UserEmail,
Customer = StripeCustomerId,
};
var chargeService = new ChargeService();
charge = chargeService.Create(chargeOptions);
}
await _db.SaveChangesAsync();
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Your payment: " + charge.Status;
return(RedirectToPage());
}
public async Task <IActionResult> Create([FromBody] CreateOrderViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _db.Users.SingleAsync(x => x.UserName == HttpContext.User.Identity.Name);
var order = new Data.Entities.Order
{
DeliveryAddress = new Data.Entities.Address
{
FirstName = model.FirstName,
LastName = model.LastName,
Address1 = model.Address1,
Address2 = model.Address2,
TownCity = model.TownCity,
County = model.County,
Postcode = model.Postcode
},
Items = model.Items.Select(x => new Data.Entities.OrderItem
{
ProductId = x.ProductId,
ColourId = x.ColourId,
StorageId = x.StorageId,
Quantity = x.Quantity
}).ToList()
};
user.Orders.Add(order);
await _db.SaveChangesAsync();
var total = await _db.Orders
.Where(x => x.Id == order.Id)
.Select(x => Convert.ToInt32(x.Items.Sum(i => i.ProductVariant.Price * i.Quantity) * 100))
.SingleAsync();
var options = new ChargeCreateOptions
{
Amount = total,
Description = $"Order {order.Id} payment",
Currency = "GBP",
Source = model.StripeToken
};
var service = new ChargeService();
var charge = service.Create(options);
if (string.IsNullOrEmpty(charge.FailureCode))
{
order.PaymentStatus = PaymentStatus.Paid;
}
else
{
order.PaymentStatus = PaymentStatus.Declined;
}
await _db.SaveChangesAsync();
return(Ok(new CreateOrderResponseViewModel(order.Id, order.PaymentStatus)));
}
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 }));
}
public async Task <IActionResult> CheckoutPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
List <OrderDetail> orderDetails = new List <OrderDetail>();
_db.OrderHeader.Add(detailCart.OrderHeader);
await _db.SaveChangesAsync();
detailCart.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in detailCart.listCart)
{
item.Productitem = await _db.ProductsModel.FirstOrDefaultAsync(m => m.Id == item.ProductId);
OrderDetail orderdetails = new OrderDetail
{
ProductItemId = item.ProductId,
OrderId = detailCart.OrderHeader.Id,
Description = item.Productitem.About,
Name = item.Productitem.Name,
Price = item.Productitem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderdetails.Price;
_db.OrderDetail.Add(orderdetails);
}
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32("ssCartCount", 0);
await _db.SaveChangesAsync();
var options = new ChargeCreateOptions
{
Amount = 10000,
Currency = "usd",
Source = stripeToken,
Description = "Order Id : " + detailCart.OrderHeader.Id,
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "Succeeded")
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
await _db.SaveChangesAsync();
return(RedirectToAction("Confirm", "Order"));
}
public IActionResult SummaryPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
ShoppingCartVM.OrderHeader.ApplicationUser = _unitOfWork.ApplicationUser
.GetFirstOrDefault(c => c.Id == claim.Value,
includeProperties: "Company");
ShoppingCartVM.ListCart = _unitOfWork.ShoppingCart.GetAll(c => c.ApplicationUserId == claim.Value,
includeProperties: "Product");
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusPending;
ShoppingCartVM.OrderHeader.ApplicationUserId = claim.Value;
ShoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
_unitOfWork.OrderHeader.Add(ShoppingCartVM.OrderHeader);
_unitOfWork.Save();
//List<OrderDetails> orderDetailsList = new List<OrderDetails>();
foreach (var item in ShoppingCartVM.ListCart)
{
// calculate Price
item.Price = SD.GetPriceBasedOnQuantity(item.Count, item.Product.Price,
item.Product.Price50, item.Product.Price100);
OrderDetails orderDetails = new OrderDetails()
{
ProductId = item.ProductId,
OrderId = ShoppingCartVM.OrderHeader.Id,
Price = item.Price,
Count = item.Count
};
ShoppingCartVM.OrderHeader.OrderTotal += orderDetails.Count * orderDetails.Price;
_unitOfWork.OrderDetails.Add(orderDetails);
//_unitOfWork.Save();
}
// remove from shopping cart and from session (for Home/Index view)
_unitOfWork.ShoppingCart.RemoveRange(ShoppingCartVM.ListCart);
_unitOfWork.Save();
HttpContext.Session.SetInt32(SD.ssShoppingCart, 0);
if (stripeToken == null)
{
// it's null for AuthorizedCompany User - they can place an order without payment(payment on delivery)
// order will be created for delayed payment for authorized company
// can be paid in 30 days
ShoppingCartVM.OrderHeader.PaymentDueDate = DateTime.Now.AddDays(30);
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusDelayedPayment;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
}
else
{
// process the payment using Stripe
//
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(ShoppingCartVM.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID: " + ShoppingCartVM.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.Id == null)
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
ShoppingCartVM.OrderHeader.TransactionId = charge.Id;
}
if (charge.Status.ToLower() == "succeded")
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
ShoppingCartVM.OrderHeader.PaymentDate = DateTime.Now;
}
}
_unitOfWork.Save();
return(RedirectToAction("OrderConfirmation", "Cart", new { id = ShoppingCartVM.OrderHeader.Id }));
}
public async Task <bool> Payment(OrderItemsVm itemsVm, string username)
{
var orderVms = itemsVm.orderedProducts;
var addressVm = itemsVm.address;
var token = itemsVm.token;
StripeConfiguration.ApiKey = System.Environment.GetEnvironmentVariable("STRIPE_SKKEY");
if (orderVms.Count == 0 || orderVms == null)
{
throw new Exception("The order is null or empty.");
}
var bucketEntity = await _dbContext.Orders
.Include(o => o.Items)
.ThenInclude(c => c.Coffee)
.Where(o => o.ClientId == username)
.FirstOrDefaultAsync(o => o.IsPaymentCompleted == false);
if (bucketEntity == null || bucketEntity.Items.Count == 0)
{
throw new Exception("Bucket is empty");
}
long dbPriceSum = 0;
foreach (OrderVm order in orderVms)
{
var item = bucketEntity.Items.FirstOrDefault(i => i.Id == order.id);
dbPriceSum += (long)(item.Price * 100);
if (item.Id != order.id)
{
throw new Exception("The order's id is invalid");
}
item.PaymentStatus = (PaymentStatus)2;
_dbContext.OrderItems.Update(item);
}
await _dbContext.SaveChangesAsync();
var amount = (long)(orderVms.Sum(o => o.price) * 100);
if (amount != dbPriceSum)
{
return(false);
}
bucketEntity.City = addressVm.place;
bucketEntity.Street = addressVm.road;
bucketEntity.HouseNumber = addressVm.houseNumber;
bucketEntity.PostalCode = addressVm.zipcode;
bucketEntity.Latitude = addressVm.latLng.latitude;
bucketEntity.Longitude = addressVm.latLng.longitude;
_dbContext.Update(bucketEntity);
await _dbContext.SaveChangesAsync();
var options = new ChargeCreateOptions
{
Amount = amount,
Currency = "pln",
Description = "Płatność",
Source = token
};
var service = new ChargeService();
Charge charge = service.Create(options);
bucketEntity.PaymentMethod = charge.PaymentMethodDetails.Card.Brand;
bucketEntity.PaymentCard = "**** **** **** " + charge.PaymentMethodDetails.Card.Last4;
await _dbContext.SaveChangesAsync();
return(true);
}
public IActionResult OnPost(string stripeToken)
{
DonationCauseObj = _unitOfWork.DonationCause.GetFirstOrDefault(c => c.Id == Int32.Parse(HttpContext.Session.GetString("donationCauseId")));
if (ModelState.IsValid)
{
if (User.Identity.IsAuthenticated)
{
var claimIdentity = (ClaimsIdentity)User.Identity;
var claim = claimIdentity.FindFirst(ClaimTypes.NameIdentifier);
DonationDetails.UserId = claim.Value;
}
else
{
DonationDetails.UserId = null;
}
DonationDetails.PaymentStatus = SD.PaymentStatusPending;
DonationDetails.DonationDate = DateTime.Now;
DonationDetails.DonationCauseId = DonationCauseObj.Id;
if (stripeToken != null)
{
var options = new ChargeCreateOptions
{
//Amount in cents
Amount = Convert.ToInt32(DonationDetails.DonationTotal * 100),
Currency = "usd",
Description = "This is a donation. See details for Transaction ID (in the upper right-hand corner of this charge's details page)",
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
DonationDetails.TransactionId = charge.Id;
if (charge.Status.ToLower() == "succeeded")
{
//send confirmation email
EmailSender emailSender;
emailSender = new EmailSender(_authOptions);
double amount = DonationDetails.DonationTotal;
decimal a;
a = Convert.ToDecimal(amount);
emailSender.SendEmailAsync(DonationDetails.Email, "Thank you for your donation to No Poor Africa!", "Donation amount: " + amount.ToString("C2") + "\n" + "Donation ID: " + DonationDetails.TransactionId);
DonationDetails.PaymentStatus = SD.PaymentStatusApproved;
}
else
{
DonationDetails.PaymentStatus = SD.PaymentStatusRejected;
}
}
_unitOfWork.DonationDetails.Add(DonationDetails);
_unitOfWork.Save();
HttpContext.Session.Remove("donationCauseId");
return(RedirectToPage("/User/DonationCause/DonationConfirmation", new { id = DonationDetails.TransactionId }));
}
else
{
ViewData["Title"] = DonationCauseObj.Title;
ViewData["Image"] = DonationCauseObj.Image;
return(Page());
}
}
public ActionResult Create(ChargeDTO chargeDTO, int ID)
{
double price = 0;
StringBuilder sb = new StringBuilder();
StripeConfiguration.ApiKey = "sk_test_51HHZalIRpf7rAmeBgc0q7aD4yiOcIaPjGCZ60FvMO4Yje4RnstURkwhMYOILHmZJwYHTzhq02OdsQDs1oP3ERsIS00k3aejALI";
var x = c.Packages.Where(e => e.ID == ID);
foreach (var item in x)
{
price = item.Price * 4.3478;
sb.AppendFormat("NT Travel Guide xin cảm ơn quý khách đã sử dụng dịch vụ của chúng tôi. " +
"Quý khách đã thanh toán thành công. Xin vui lòng kiểm tra lại các thông tin sau: \n" +
"Điểm đến: {0}\n" +
"Ngày xuất phát: {3}-{2}-{1}\n" +
"Chuyến đi trong vòng: {4}\n" +
"Mã vé: NT{5}\n\n" +
"Trân trọng,\nNT Travel Guide\n" +
"Nếu những thông tin trên có sai sót hoặc quý khách có thắc mắc về chuyến đi, xin phản hồi lại email này.\n" +
"\nHoặc gọi vào hotline: 028-38364748 để được hỗ trợ tốt nhất.\nXin chân thành cảm ơn.", item.Destination, item.Depart.Year, item.Depart.Month, item.Depart.Day, item.Offer, item.ID);
}
var customerOptions = new CustomerCreateOptions
{
Description = chargeDTO.CardName,
Source = chargeDTO.StripeToken,
Email = chargeDTO.Email,
Metadata = new Dictionary <String, String>()
{
{ "Phone Number", chargeDTO.Phone }
}
};
var customerService = new CustomerService();
Customer customer = customerService.Create(customerOptions);
var options = new ChargeCreateOptions
{
Amount = (long)price,
Currency = "usd",
Description = "Charge for [email protected]",
Customer = customer.Id
};
var service = new ChargeService();
Charge charge = service.Create(options);
var model = new ChargeViewModel();
model.ChargeId = charge.Id;
model.Name = customer.Name;
model.Email = customer.Email;
// Send mail for client
MailMessage mail = new MailMessage();
mail.From = new System.Net.Mail.MailAddress("*****@*****.**");
mail.Subject = "[MAIL XÁC NHẬN]";
SmtpClient smtp = new SmtpClient();
smtp.Port = 587;
smtp.EnableSsl = true;
smtp.DeliveryMethod = SmtpDeliveryMethod.Network;
smtp.UseDefaultCredentials = false;
smtp.Credentials = new NetworkCredential(mail.From.ToString(), "daylamatkhaumanhduocchua?");
smtp.Host = "smtp.gmail.com";
// Recipient address
mail.To.Add(new MailAddress(customer.Email));
// Formatted mail body;
string st = "Xin chào anh/chị " + customer.Description + ", \n" + sb;
mail.Body = st;
smtp.Send(mail);
return(View("OrderStatus", model));
}
public bool Pay(
string CardNo,
int ExpiredYear, int ExpiredMonth,
string CVV,
decimal amount, string currency,
string receiptEmail = "", string description = "")
{
try
{
TokenCreateOptions stripeCard = new TokenCreateOptions
{
Card = new TokenCardOptions
{
Number = CardNo,
ExpMonth = Convert.ToInt64(ExpiredMonth),
ExpYear = Convert.ToInt64(ExpiredYear),
Cvc = CVV,
},
};
TokenService service = new TokenService();
Token newToken = service.Create(stripeCard);
var cardOption = new SourceCreateOptions
{
Type = SourceType.Card,
Currency = currency,
Token = newToken.Id
};
var sourceService = new SourceService();
Source source = sourceService.Create(cardOption);
/*
* CustomerCreateOptions customerInfo = new CustomerCreateOptions
* {
* Name = "SP Tutorial",
* Email = stripeEmail,
* Description = "Paying 10 Rs",
* Address = new AddressOptions {
* City = "Kolkata",
* Country = "India",
* Line1 = "Sample Address",
* Line2 = "Sample Address 2",
* PostalCode = "700030",
* State = "WB"
* }
* };
*
* //var customerService = new CustomerService();
* //var customer = customerService.Create(customerInfo);
*/
var chargeoption = new ChargeCreateOptions
{
Amount = Convert.ToInt32(amount * 100),
Currency = currency,
Description = description,
ReceiptEmail = receiptEmail,
Source = source.Id
};
var chargeService = new ChargeService();
Charge charge = chargeService.Create(chargeoption);
if (charge.Status == "succeeded")
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
Console.WriteLine(e);
return(false);
}
}
private void Button1_Click_1(object sender, EventArgs e)
{
//This is the same code above only difference is Source i could add in a check above to see if CustomerID is empty but i think its easier to help people understand the difference.
try
{
/*
* Using Stripe's library to make request
* Everything below is from the Official Documentation
* From https://stripe.com/docs/api
*
*/
//Set To public key so we can create a Card Card Object
StripeConfiguration.ApiKey = MainForm.PubKey;
//No Error Check Added so must be added in
//Getting User Information
int PriceToCharge = (Int32.Parse(ChargeAmmount.Text)) * 100;
string DescriptionText = DescBox.Text;
string CustomerID = CustomerIDBox.Text;
//Generating MetaData
Dictionary <String, String> MetadataToAdd = new Dictionary <String, String>()
{
{ "ItemID", ItemIDBox.Text },
{ "ItemName", ItemNameBox.Text },
{ "Country", CountryBox.Text }
};
//Set To Private key to tell API that we are Charging.
StripeConfiguration.ApiKey = MainForm.SecretKey;
//Ive Tried to add as much Paramters into the ChargeOptions as incase you find something useful. The Only Things you Require is Amount, Currency and Source.
var ChargeOptions = new ChargeCreateOptions
{
Amount = PriceToCharge,
Currency = "gbp",
Description = DescriptionText,
Metadata = MetadataToAdd,
CustomerId = CustomerID,
//Source = "tok_mastercard" //Not Putting in a source defaults to customers default payment method
};
//Creating a Service To Charge the Card
var ChargeService = new ChargeService();
Charge charge = ChargeService.Create(ChargeOptions);
//No Error
MessageBox.Show("Successfully Charged Customer");
}
catch (StripeException ex)
{
//Switch Statement is from API Documentation
switch (ex.StripeError.ErrorType)
{
case "card_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "api_connection_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "api_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "authentication_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "invalid_request_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "rate_limit_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "validation_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
default:
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
// Unknown Error Type
break;
}
}
}
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");
}
private void Button1_Click(object sender, EventArgs e)
{
try
{
/*
* Using Stripe's library to make request
* Everything below is from the Official Documentation
* From https://stripe.com/docs/api
*
*/
//Set To public key so we can create a Card Card Object
StripeConfiguration.ApiKey = MainForm.PubKey;
//Getting Card & Price Information // No Error Checks added so it can crash the program
int Month = Int32.Parse(MonthExpiry.Text);
int Year = Int32.Parse(YearExpiry.Text);
int PriceToCharge = (Int32.Parse(ChargeAmmount.Text)) * 100;
string CardNo = CardNoBox.Text;
string CVCText = SecCode.Text;
string UserEmail = EmailBox.Text;
string DescriptionText = DescBox.Text;
//Generating MetaData
Dictionary <String, String> MetadataToAdd = new Dictionary <String, String>()
{
{ "ItemID", ItemIDBox.Text },
{ "ItemName", ItemNameBox.Text },
{ "Country", CountryBox.Text }
};
//Creating A Token to "Build" the card.
var TokenOptions = new TokenCreateOptions
{
Card = new CreditCardOptions //Card Object
{
Number = CardNo,
ExpYear = Year,
ExpMonth = Month,
Cvc = CVCText
}
};
//Creating a Token and attaching Card Object
var Tokenservice = new TokenService();
Token stripeToken = Tokenservice.Create(TokenOptions);
//Set To Private key to tell API that we are Charging.
StripeConfiguration.ApiKey = MainForm.SecretKey;
//Ive Tried to add as much Paramters into the ChargeOptions as incase you find something useful. The Only Things you Require is Amount, Currency and Source.
var ChargeOptions = new ChargeCreateOptions
{
Amount = PriceToCharge,
Currency = "gbp",
ReceiptEmail = UserEmail,
Description = DescriptionText,
Metadata = MetadataToAdd,
Source = "tok_mastercard" // obtained with Stripe.js
};
//Creating a Service To Charge the Card
var ChargeService = new ChargeService();
Charge charge = ChargeService.Create(ChargeOptions);
//No Error
MessageBox.Show("Successfully Charged Card");
}
catch (StripeException ex)
{
//Switch Statement is from API Documentation
switch (ex.StripeError.ErrorType)
{
case "card_error":
MessageBox.Show("Code: " + ex.StripeError.Code);
MessageBox.Show("Message: " + ex.StripeError.Message);
break;
case "api_connection_error":
break;
case "api_error":
break;
case "authentication_error":
break;
case "invalid_request_error":
break;
case "rate_limit_error":
break;
case "validation_error":
break;
default:
// Unknown Error Type
break;
}
}
}
public async Task <IActionResult> SummaryPOST(string stripeToken)
{
/*PROCESS FLOW OF THE STRIPE TOKEN
* When the user enters the credit card details and clicks the submit button,
* All the details are posted on the stripe server directly and are not saved anyhere on our server,
* Using the card numbers and details, stripe generates a token and sends the token to the post action method in the controller,
* We will use the token in the controller and pass it to make the actual charge
*/
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.ListCart = await _db.ShoppingBag.Where(c => c.ApplicationUserId == claim.Value).ToListAsync(); //retrieving all of the shopping cart
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending; //because we'll be calculating that when we need userid of the user that is logged in, to retrieve all the items in the shopcart the user has
detailCart.OrderHeader.OrderDate = DateTime.Now; //because we'll be calculating that when we need userid of the user that is logged in, to retrieve all the items in the shopcart the user has
detailCart.OrderHeader.UserId = claim.Value; //because we'll be calculating that when we need userid of the user that is logged in, to retrieve all the items in the shopcart the user has
detailCart.OrderHeader.Status = SD.PaymentStatusPending; //because we'll be calculating that when we need userid of the user that is logged in, to retrieve all the items in the shopcart the user has
detailCart.OrderHeader.PickUpTime = Convert.ToDateTime(detailCart.OrderHeader.PickUpDate.ToShortDateString() + " " + detailCart.OrderHeader.PickUpTime.ToShortTimeString()); //because we'll be calculating that when we need userid of the user that is logged in, to retrieve all the items in the shopcart the user has
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_db.OrderHeader.Add(detailCart.OrderHeader);
await _db.SaveChangesAsync();
var details = detailCart.OrderHeader.OrderTotalOriginal;
foreach (var item in detailCart.ListCart)//Calculate the order total so far
{
item.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
//Creating order details
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
details = orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
await _db.SaveChangesAsync();
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = details;
}
detailCart.OrderHeader.CouponCodeDiscount = details - detailCart.OrderHeader.OrderTotal;
_db.ShoppingBag.RemoveRange(detailCart.ListCart);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
await _db.SaveChangesAsync();
//making the call (transaction) to stripe for getting our payment
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + detailCart.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);//This will do the actual transaction
//check if there is a transaction ID
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
await _db.SaveChangesAsync();
//return RedirectToAction("Index", "Home");
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));//with a confirm action and a order header id
}
public async Task <IActionResult> SummaryPOST(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier); //--> we want to know Logged in users.
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync(); //--> Retriev the shopping cart.
detailCart.OrderHeader.PaymentStatus = SD.PaymentPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentPending;
detailCart.OrderHeader.PickUpTime = Convert.ToDateTime(detailCart.OrderHeader.PickUpDate.ToShortDateString() + " " + detailCart.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_db.OrderHeader.Add(detailCart.OrderHeader); //--> we make order header into our database.
await _db.SaveChangesAsync();
detailCart.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in detailCart.listCart)
{
item.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count,
};
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode); //--> we need to check that session and display the price accordingly.
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotalOriginal;
}
detailCart.OrderHeader.CouponCodeDiscount = detailCart.OrderHeader.OrderTotalOriginal - detailCart.OrderHeader.OrderTotalOriginal;
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
await _db.SaveChangesAsync();
//----//
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + detailCart.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
//---//
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "Succeeded")
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentRejected;
}
await _db.SaveChangesAsync();
return(RedirectToAction("Index", "Home"));
//return RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id });
}
public ResultAndMessage ChargeAccountToAccount(string BuyerCustId,
string VendorAcctId,
decimal purchaseAmount,
decimal smFee)
{
ResultAndMessage result = new ResultAndMessage();
var charge = new ChargeCreateOptions
{
// What is this property?
//----------------------------------------
//charge.OnBehalfOf = stripeAcctId;
//-----------------------------------
// When you create destination charges on the platform account,
// Stripe automatically:
// -Settles charges in the country of the specified account,
// thereby minimizing declines
// -Uses the connected account’s currency for settlement,
// often avoiding currency conversions
// -Uses the fee structure for the connected account’s country
// This same functionality is not automatically provided when creating
// separate charges and transfers, but you can replicate it using
// the on_behalf_of attribute when creating the charge.
// Setting on_behalf_of defines the business of record for the charge
// and funds will be settled using that account.
// For Custom Accounts, simplest route
// create the charge on platform’s account
// destination parm - connected account that receives funds.
Destination = new ChargeDestinationCreateOptions()
{
Account = VendorAcctId
},
// always set these properties
Amount = purchaseAmount.ToPennies(),
Currency = "usd",
// two-step payments: you can first authorize a charge
// on your customer’s card, then wait to settle (capture)
// it later. When a charge is authorized, the funds are guaranteed
// by the issuing bank and the amount held on the customer’s card
// for up to seven days. If the charge is not captured within this time,
// the authorization is canceled and funds released.
// To authorize a payment without capturing it, make a charge request
// that also includes the capture parameter with a value of false.
// This instructs Stripe to only authorize the amount
// on the customer’s card.
//charge.Capture = false;
// Here's second step if two-step is employed
//var chargeService = new StripeChargeService();
//charge = chargeService.Capture({ CHARGE_ID});
// set this if you want to
Description = "simple-market purchase",
//charge.SourceTokenOrExistingSourceId = BuyerAcctId;
// set this property if using a customer
// - this MUST be set if you are using an existing source!
Customer = BuyerCustId,
ApplicationFeeAmount = smFee.ToPennies()
};
//string secKey = _cntxt.smAdmin.Single(r => r.type == AdminRecType.secKey).strData;
//if (string.IsNullOrEmpty(secKey))
//{
// result.message = "failure to fetch stripe key.";
// return result;
//}
//StripeConfiguration.SetApiKey(secKey);
var chargeService = new ChargeService();
Charge stripeCharge = chargeService.Create(charge);
result.success = true;
return(result);
}
public async Task <IActionResult> SummeryPost(string stripeToken)
{
//Saving OrderHeader To database
var claimsIdentity = (ClaimsIdentity)this.User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier).Value;
DetailsCartVM.ShoppingCartList = await _db.ShoppingCart.Where(u => u.ApplicationUserId == claim).ToListAsync();
DetailsCartVM.OrderHeader.PaymentStatus = SD.StatusPending;
DetailsCartVM.OrderHeader.Status = SD.StatusPending;
DetailsCartVM.OrderHeader.ApplicationUserId = claim;
DetailsCartVM.OrderHeader.OrderDate = DateTime.Now;
DetailsCartVM.OrderHeader.PickUpTime = Convert.ToDateTime(DetailsCartVM.OrderHeader.PickUpDate.ToShortDateString() + " " + DetailsCartVM.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_db.OrderHeaders.Add(DetailsCartVM.OrderHeader);
await _db.SaveChangesAsync();
DetailsCartVM.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in DetailsCartVM.ShoppingCartList)
{
item.MenuItem = await _db.MenuItems.FirstOrDefaultAsync(u => u.MenuItemId == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
OrderId = DetailsCartVM.OrderHeader.OrderHeaderId,
MenuItemId = item.MenuItemId,
Count = item.Count,
ItemName = item.MenuItem.MenuItemName,
Price = item.MenuItem.Price
};
DetailsCartVM.OrderHeader.OrderTotalOriginal += item.Count * item.MenuItem.Price;
_db.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
DetailsCartVM.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var coupon = _db.Coupons.FirstOrDefault(u => u.CouponName.ToLower() == DetailsCartVM.OrderHeader.CouponCode.ToLower());
DetailsCartVM.OrderHeader.OrderTotal = SD.DiscountedPrice(coupon, DetailsCartVM.OrderHeader.OrderTotalOriginal);
}
else
{
DetailsCartVM.OrderHeader.OrderTotal = DetailsCartVM.OrderHeader.OrderTotalOriginal;
}
DetailsCartVM.OrderHeader.CouponCodeDiscount = DetailsCartVM.OrderHeader.OrderTotalOriginal - DetailsCartVM.OrderHeader.OrderTotal;
_db.ShoppingCart.RemoveRange(DetailsCartVM.ShoppingCartList);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
await _db.SaveChangesAsync();
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32((DetailsCartVM.OrderHeader.OrderTotal / 80) * 100),
Currency = "usd",
Description = "Order Id : " + DetailsCartVM.OrderHeader.OrderHeaderId,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.Status.ToLower() == "succeeded")
{
DetailsCartVM.OrderHeader.TransactionId = charge.BalanceTransactionId;
await _emailSender.SendEmailAsync(_db.Users.Where(u => u.Id == claim).FirstOrDefault().Email,
"ForYou payment completed OrderId: " + DetailsCartVM.OrderHeader.OrderHeaderId.ToString(),
"You have paid " + DetailsCartVM.OrderHeader.OrderTotal.ToString() + " for your Order<br /> <strong class =\"text-info\">THANK YOU!!</strong>");
DetailsCartVM.OrderHeader.PaymentStatus = SD.StatusApproved;
DetailsCartVM.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
await _emailSender.SendEmailAsync(_db.Users.Where(u => u.Id == claim).FirstOrDefault().Email,
"ForYou payment completed OrderId: " + DetailsCartVM.OrderHeader.OrderHeaderId.ToString(),
"Your payment request failed anyway. Please contuct us for more information.<br /> <strong class =\"text-info\">THANK YOU!!</strong>");
DetailsCartVM.OrderHeader.PaymentStatus = SD.StatusRejected;
}
await _db.SaveChangesAsync();
//return RedirectToAction("Index", "Cart");
return(RedirectToAction("Confirm", "Order", new { id = DetailsCartVM.OrderHeader.OrderHeaderId }));
}
public IActionResult OnPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = _unitOfWork.ShoppingCart.GetAll(c => c.ApplicationUserId == claim.Value).ToList();
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
detailCart.OrderHeader.PickUpTime = Convert.ToDateTime(detailCart.OrderHeader.PickUpDate.ToShortDateString() + " " + detailCart.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_unitOfWork.OrderHeader.Add(detailCart.OrderHeader);
_unitOfWork.Save();
foreach (var item in detailCart.listCart)
{
item.MenuItem = _unitOfWork.MenuItem.GetFirstOrderDefault(m => m.Id == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotal += (orderDetails.Count * orderDetails.Price);
_unitOfWork.OrderDetails.Add(orderDetails);
}
detailCart.OrderHeader.OrderTotal = Convert.ToDouble(String.Format("{0:.##}", detailCart.OrderHeader.OrderTotal));
_unitOfWork.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ShoppingCart, 0);
_unitOfWork.Save();
if (stripeToken != null)
{
var options = new ChargeCreateOptions
{
//Amount is in cents
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + detailCart.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
detailCart.OrderHeader.TransactionId = charge.Id;
if (charge.Status.ToLower() == "succeeded")
{
//email
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
_unitOfWork.Save();
return(RedirectToPage("/Customer/Card/OrderConfirmation", new { id = detailCart.OrderHeader.Id }));
}
public async Task <IActionResult> Create(Order frmOrder)
{
if (ModelState.IsValid)
{
var user = _identitySvc.Get(HttpContext.User);
Order order = frmOrder;
order.UserName = user.Email;
order.BuyerId = user.Email;
var options = new RequestOptions
{
ApiKey = _config["StripePrivateKey"]
};
var chargeOptions = new ChargeCreateOptions()
{
//required
Amount = (int)(order.OrderTotal * 100),
Currency = "usd",
Source = order.StripeToken,
//optional
Description = string.Format("Order Payment {0}", order.UserName),
ReceiptEmail = order.UserName,
};
var chargeService = new ChargeService();
Charge stripeCharge = null;
try
{
stripeCharge = chargeService.Create(chargeOptions, options);
_logger.LogDebug("Stripe charge object creation" + stripeCharge.StripeResponse.ToString());
}
catch (StripeException stripeException)
{
_logger.LogDebug("Stripe exception " + stripeException.Message);
ModelState.AddModelError(string.Empty, stripeException.Message);
return(View(frmOrder));
}
try
{
if (stripeCharge.Id != null)
{
order.PaymentAuthCode = stripeCharge.Id;
int orderId = await _orderSvc.CreateOrder(order);
return(RedirectToAction("Complete", new { id = orderId, userName = user.UserName }));
}
else
{
ViewData["message"] = "Payment cannot be processed, try again";
return(View(frmOrder));
}
}
catch (BrokenCircuitException)
{
ModelState.AddModelError("Error", "It was not possible to create a new order, please try later on. (Business Msg Due to Circuit-Breaker)");
return(View(frmOrder));
}
}
else
{
return(View(frmOrder));
}
}
public IActionResult SummaryPost(ShoppingCartVM shoppingCartVM, string stripeToken)
{
Claim claim = GetClaim();
shoppingCartVM.OrderHeader.ApplicationUser = unitOfWork.ApplicationUser
.GetFirstOrDefault(c => c.Id == claim.Value, includeProperties: "Company");
shoppingCartVM.ListCart = unitOfWork.ShoppingCart
.GetAll(c => c.ApplicationUserId == claim.Value, includeProperties: "Product");
shoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
shoppingCartVM.OrderHeader.OrderStatus = SD.StatusPending;
shoppingCartVM.OrderHeader.ApplicationUserId = claim.Value;
shoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
unitOfWork.OrderHeader.Add(shoppingCartVM.OrderHeader);
unitOfWork.Save();
foreach (var item in shoppingCartVM.ListCart)
{
item.Price = SetPrice(item);
OrderDetails orderDetails = new OrderDetails()
{
ProductId = item.ProductId,
OrderId = shoppingCartVM.OrderHeader.Id,
Price = item.Price,
Count = item.Count
};
shoppingCartVM.OrderHeader.OrderTotal += orderDetails.Count * orderDetails.Price;
unitOfWork.OrderDetails.Add(orderDetails);
}
unitOfWork.ShoppingCart.RemoveRange(shoppingCartVM.ListCart);
// Save in one call to remove cart and add order details
unitOfWork.Save();
HttpContext.Session.SetInt32(SD.ShoppingCartSession, 0);
// Should only be null if the user ordering is an authorized company
if (stripeToken == null)
{
//order will be created for delayed payment for authroized company
shoppingCartVM.OrderHeader.PaymentDueDate = DateTime.Now.AddDays(30);
shoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusDelayedPayment;
shoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
}
else
{
//process the payment
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(shoppingCartVM.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + shoppingCartVM.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
// Makes charge on card
Charge charge = service.Create(options);
if (charge.Id == null)
{
shoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
shoppingCartVM.OrderHeader.TransactionId = charge.Id;
}
if (charge.Status.ToLower() == "succeeded")
{
shoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
shoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
shoppingCartVM.OrderHeader.PaymentDate = DateTime.Now;
}
}
unitOfWork.Save();
return(RedirectToAction("OrderConfirmation", "Cart", new { id = shoppingCartVM.OrderHeader.Id }));
}
/// <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 <IActionResult> SummaryPost(string stripeToken, OrderHeader orderHeader, OrderDetailsCart orderdetailsCart)
{
//-- sega dobaveno
//var detailCart = new Models.ViewModels.OrderDetailsCart()
//{
// OrderHeader = orderHeader
//};
//-- do tuk
//var detalCart = orderdetailsCart;
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_db.OrderHeader.Add(detailCart.OrderHeader);
await _db.SaveChangesAsync();
foreach (var item in detailCart.listCart)
{
item.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Desctiopion = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
}
// detailCart.OrderHeader.OrderTotalOriginal = detailCart.OrderHeader.OrderTotal;
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotalOriginal;
}
detailCart.OrderHeader.CouponCodeDiscount = detailCart.OrderHeader.OrderTotalOriginal - detailCart.OrderHeader.OrderTotal;
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ssShopingCartCount, 0);
await _db.SaveChangesAsync();
//to execute the actual payment and charge the credit card
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "BGN",
Description = "Order ID: " + detailCart.OrderHeader.Id,
Source = stripeToken
};
//
var service = new ChargeService();
//to make the actual trasaction
Charge charge = service.Create(options);
//check the result
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
//send order confirmation Email to the customer
await _emailSender.SendEmailAsync(_db.Users.Where(u => u.Id == claim.Value).FirstOrDefault().Email,
"Lazy Dayze order " + detailCart.OrderHeader.Id.ToString() + " successfully accepted!",
"You order number " + detailCart.OrderHeader.Id.ToString() + " has been submitted successfully");
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
//
await _db.SaveChangesAsync();
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));
// return RedirectToAction("Index", "Home");
}
public async Task <IActionResult> SummaryPost(string stripeToken)
{
//---User id of logged user
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
//---Modify detail cart
//---Retrieve shopping cart
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
//
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
detailCart.OrderHeader.PickupTime = Convert.ToDateTime(detailCart.OrderHeader.PickupDate.ToShortDateString() + " " + detailCart.OrderHeader.PickupTime.ToShortTimeString());
//---List of order details
List <OrderDetails> orderDetatilsList = new List <OrderDetails>();
_db.OrderHeader.Add(detailCart.OrderHeader);
//--Order header created in DB
await _db.SaveChangesAsync();
detailCart.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in detailCart.listCart)
{
item.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
//--For each item, calculate and add to total
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
}
//---Use of coupon code and update the price
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
//---Coupon Applied, updating order total
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotalOriginal;
}
detailCart.OrderHeader.CouponCodeDiscount = detailCart.OrderHeader.OrderTotalOriginal - detailCart.OrderHeader.OrderTotal;
//---Remove from session and shopping cart
await _db.SaveChangesAsync();
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
//---Saving everything
await _db.SaveChangesAsync();
//---Stripe funcionality
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID: " + detailCart.OrderHeader.Id,
SourceId = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
//---Check if there is a transaction id
if (charge.BalanceTransactionId == null)
{
//---There was a problem, report
detailCart.OrderHeader.Status = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
//Payment approved!
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
//---Not approved
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
//---Finally, save changes
await _db.SaveChangesAsync();
//---For testing purposes
//return RedirectToAction("Index", "Home");
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));
}
public async Task <IActionResult> SummaryPost(string stripeEmail, string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
detailCart.OrderHeader.PickUpTime = Convert.ToDateTime(detailCart.OrderHeader.PickUpDate.ToShortDateString() + " " + detailCart.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_db.OrderHeader.Add(detailCart.OrderHeader);
await _db.SaveChangesAsync();
detailCart.OrderHeader.OrderTotalOriginal = 0;
ApplicationUser applicationUser = await _db.ApplicationUser.Where(c => c.Id == claim.Value).FirstOrDefaultAsync();
foreach (var item in detailCart.listCart)
{
item.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Descrption = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotalOriginal;
}
detailCart.OrderHeader.CouponCodeDiscount = detailCart.OrderHeader.OrderTotalOriginal - detailCart.OrderHeader.OrderTotal;
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
await _db.SaveChangesAsync();
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + detailCart.OrderHeader.Id,
SourceId = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
await _emailSender.SendEmailAsync(_db.Users.Where(u => u.Id == claim.Value).FirstOrDefault().Email, "Spice - Order Created" + detailCart.OrderHeader.Id.ToString(), "Order has been submitted successfully.");
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
await _db.SaveChangesAsync();
// return RedirectToAction("Index", "Home");
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));
}
public async Task <ActionResult> contratLocationClient(String stripeToken, decimal idLocation)
{
Location currentLocation = db.Location.FirstOrDefault(p => p.id == idLocation);
if (currentLocation == null)
{
TempData["result_code"] = -1;
TempData["message"] = "Temps fourni pour le payment est expiré veuillez réessayer.";
TempData.Keep();
//TODO rediriger a la liste des candidatures
return(RedirectToAction("mesDemandeLocation"));
}
Inscrire candidat = db.Inscrire.Where(p => p.id == currentLocation.Ins_id).First();
if (candidat == null)
{
return(HttpNotFound());
}
Inscrire client = db.Inscrire.Where(p => p.id == currentLocation.Ins_id2).First();
if (client == null)
{
return(HttpNotFound());
}
if (String.IsNullOrEmpty(stripeToken))
{
return(HttpNotFound());
}
StripeConfiguration.SetApiKey("sk_test_51Gx6jgIK0UhIWHGbs9dcTW7tyGLkl39s6waxls9Z5D8E0arsL4bjy9N0g563Tlzo5JNvbeFOkAl5fMEY85eerPIx00mYJFiqLY");
var stripeOptions = new ChargeCreateOptions
{
Amount = (long)Math.Ceiling(currentLocation.remuneration.Value) * 35 / 100, // 1 dollar is equal to 100 cent.
Currency = "USD",
Description = "Charge for payment of 35% of Location",
Source = stripeToken,
//Customer = customer.Id
};
var service = new ChargeService();
if (Session["id"] == null)
{
return(HttpNotFound());
}
int idUserSession = Convert.ToInt32(Session["id"]);
currentLocation.dateSgnClt = DateTime.Now;
currentLocation.avisClient = 2;
currentLocation.signClient = 2;
db.Entry(currentLocation).State = EntityState.Modified;
double amount = (long)Math.Ceiling(currentLocation.remuneration.Value) * 35 / 100;
FraisLocation fraisLocation = new FraisLocation();
fraisLocation.archived = 1;
fraisLocation.avance = amount;
fraisLocation.created = DateTime.Now;
fraisLocation.etat = 0; //TODO mettre le bon etat
fraisLocation.Ins_id = candidat.id;
fraisLocation.Ins_id2 = client.id;
fraisLocation.Loc_id = currentLocation.id;
fraisLocation.libelle = "Paiement de 35% pour la location";
fraisLocation.montant = Convert.ToDouble(currentLocation.remuneration);
fraisLocation.userId = idUserSession;
fraisLocation.reste = Convert.ToDouble(currentLocation.remuneration) - amount;
fraisLocation.status = 0;
//TODO mettre le bon status je suppose o veut dire non achevé
db.FraisLocation.Add(fraisLocation);
try
{
Charge charge = service.Create(stripeOptions);
var map = new Dictionary <String, String>();
map.Add("@ViewBag.titre", "Paiement de 35% du salaire pour la location de l'employé " + candidat.login);
map.Add("@ViewBag.login", client.login);
map.Add("@ViewBag.content", "Votre paiement a bien été pris en compte. Le montant à été prélever de votre compte avec succès. Bénéficiez du meilleur de nos service.");
string body = MsMail.BuldBodyTemplate("~/EmailTemplate/CustomEmail.cshtml", map);
var map1 = new Dictionary <String, String>();
map1.Add("@ViewBag.titre", "Vous êtes sollicité pour un travail ");
map1.Add("@ViewBag.login", candidat.login);
map1.Add("@ViewBag.content", "Votre demande de location a été confimer. Vous êtes conviez a prendre service le plutôt possible.");
string body2 = MsMail.BuldBodyTemplate("~/EmailTemplate/CustomEmail.cshtml", map1);
MsMail mail = new MsMail();
MsMail mail2 = new MsMail();
db.SaveChanges();
//TODO retraviller le mail avec du HTML
await mail.Send(client.email, "Paiement location", body);
await mail2.Send(candidat.email, "NiovarJobs, Demande location accepté ", body2);
//TODO rediriger a la liste des candidatures
return(RedirectToAction("mesDemandeLocation"));
}
catch (StripeException e)
{
// throw;
return(RedirectToAction("contratLocationClient", new { id = currentLocation.id }));
}
return(RedirectToAction("contratLocationClient", new { id = currentLocation.id }));
}
