internal async Task <int> PlaceOrderAsync(CheckoutVM input)
{
decimal?orderPrice = await GetOrderPriceAsync();
var orderTime = DateTime.Now;
Order myOrder = new Order
{
CustomerId = input.Id,
FirstName = input.FirstName,
LastName = input.LastName,
Street = input.Street,
Zip = input.Zip,
City = input.City,
Date = orderTime,
Cart = accessor.HttpContext.Request.Cookies["shoppingCart"],
TotPrice = orderPrice
};
context.Orders.Add(myOrder);
context.SaveChanges();
var result = context.Orders
.Where(p => p.Date == orderTime)
.Select(p => p.Id)
.ToArray();
return(result[0]);
}
public async Task <IActionResult> CheckoutAsync()
{
var User = await mService.GetUser();
CheckoutVM input;
if (User != null)
{
input = new CheckoutVM
{
Id = User.Id,
FirstName = User.FirstName,
LastName = User.LastName,
Email = User.Email,
Street = User.Street,
Zip = User.Zip,
City = User.City,
OrderCart = await pService.GetSummaryVMAsync()
};
}
else
{
input = new CheckoutVM
{
OrderCart = await pService.GetSummaryVMAsync()
};
};
return(View(input));
}
public async Task <IActionResult> Checkout()
{
var rqf = Request.HttpContext.Features.Get <IRequestCultureFeature>();
var culture = rqf.RequestCulture.Culture;
var cookieValue = Request.Cookies["Token"];
if (cookieValue == null)
{
return(RedirectToAction("index", "login"));
}
UserClient user = await _db.UserClients.FirstOrDefaultAsync(a => a.Token == cookieValue);
if (user == null)
{
return(RedirectToAction("index", "login"));
}
List <CartItem> carts = HttpContext.Session.GetJson <List <CartItem> >("Cart") ?? new List <CartItem>();
CheckoutVM model = new CheckoutVM {
Breadcrumb = new Breadcrumb
{
Path = new Dictionary <string, string> {
{ "Home", Url.Action("Index", "Home") },
{ "Checkout", null }
},
Page = Page.Checkout
},
LanguageId = _db.Languages.FirstOrDefault(x => x.LanguageCode == culture.ToString()).Id
};
foreach (var cart in carts)
{
if (await _db.OrderProducts.FirstOrDefaultAsync(x => x.ProductId == cart.ProductId && x.UserClientId == user.Id && x.Complete == Complete.Processsing && x.Status == true) != null)
{
_db.OrderProducts.FirstOrDefault(x => x.ProductId == cart.ProductId && x.UserClientId == user.Id && x.Complete == Complete.Processsing && x.Status == true).Quantity += cart.Quantity;
await _db.SaveChangesAsync();
}
else
{
OrderProduct orderProduct = new OrderProduct
{
ProductId = cart.ProductId,
Price = cart.Price,
Quantity = cart.Quantity,
CreatedAt = DateTime.Now,
User = user,
Status = true,
Complete = Complete.Processsing,
ColorId = cart.ColorId
};
await _db.OrderProducts.AddAsync(orderProduct);
await _db.SaveChangesAsync();
}
}
model.OrderProducts = await _db.OrderProducts.Include("Product").Where(x => x.UserClientId == user.Id && x.Status == true && x.Complete == Complete.Processsing).OrderByDescending(x => x.CreatedAt).ToListAsync();
return(View(model));
}
public void FillCountries(CheckoutVM model)
{
model.Countries = db.Countries.OrderBy(o => o.CountryName).Select(c => new SelectListItem()
{
Text = c.CountryName, Value = c.CountryId.ToString()
}).ToList();
}
public async Task <IActionResult> PaymentAsync(CheckoutVM model)
{
if (model.BrojKarata > (_context.DvoranaTipSjedista.First(w => w.TipSjedistaId == model.TipSjedistaId && w.DvoranaId == _context.Termin.First(q => q.Id == model.TerminId).DvoranaId).BrojSjedista
- _context.Narudzba.Where(w => w.TerminId == model.TerminId && w.TipSjedistaId == model.TipSjedistaId).Sum(a => (int?)a.Kolicina) ?? 0))
{
return(Redirect("~/Termini/Checkout/" + model.TerminId.ToString()));
}
Data.Models.Termin termin = _context.Termin.Include("Predstava").First(w => w.Id == model.TerminId);
Data.Models.TipSjedista tipSjedista = _context.TipSjedista.First(w => w.Id == model.TipSjedistaId);
string Naziv = termin.Predstava.Naziv + " " + termin.DatumVrijeme.ToString("dd.MM.yyyy HH:mm") + " " + tipSjedista.Naziv;
double Cijena = (termin.BaznaCijenaKarte * tipSjedista.CijenaKarteMultiplier) - (termin.BaznaCijenaKarte * tipSjedista.CijenaKarteMultiplier * _context.Kupac.Where(w => w.Username == HttpContext.User.Identity.Name).Select(s => s.TipKorisnika.CijenaKartePopust).First());
TempData["TerminId"] = model.TerminId;
TempData["BrojKarata"] = model.BrojKarata;
TempData["TipSjedistaId"] = model.TipSjedistaId;
TempData["CijenaKarte"] = Cijena;
string SucessUrl = "http://" + Request.Host.ToString() + "/Termini/Checkout/PaymentSuccess";
string CancelUrl = "http://" + Request.Host.ToString();
string link = await PayPalHelper.GeneratePayment(Naziv, (float)Cijena / 2, model.BrojKarata, SucessUrl, CancelUrl);
return(Redirect(link));
}
public ActionResult Checkout(CheckoutVM checkout)
{
decimal total = 0;
foreach (var item in cart.OrderItems)
{
total += (item.OrderItemProduct.ProductPrice * item.OrderQuantity);
}
Order currentOrder = new Order {
OrderTotal = total,
OrderItems = new List <OrderItems>(),
OrderDate = DateTime.Now,
CustomerID = (int)HttpContext.Session.GetInt32("CustomerID"),
LocationID = (int)HttpContext.Session.GetInt32("LocationID")
};
foreach (var thing in cart.OrderItems)
{
currentOrder.OrderItems.Add(new OrderItems {
OrderQuantity = thing.OrderQuantity,
ProductID = thing.ProductID
});
}
_storeBL.CreateOrder(currentOrder);
_storeBL.UpdateInventory(currentOrder);
_logger.LogWarning($"User Checkout!");
cart.OrderItems.Clear();
return(RedirectToAction("Index", "Home"));
}
public IActionResult CheckoutCart()
{
CheckoutVM model = new CheckoutVM();
model.Cart = _cart;
return(View(model));
}
public ActionResult Checkout()
{
string currency = CookieService.GetCurrency(Request.Cookies);
CheckoutVM viewModel = new CheckoutVM()
{
CurrencyCode = currency
};
// If we are a guest on the site use cookies for the shopping cart
if (!UserService.IsUserConnected(System.Web.HttpContext.Current.User))
{
// Get products using the CookieService
viewModel.Products = CookieService.GetShoppingCartProducts(Request.Cookies);
viewModel.Subtotal = ShoppingCartService.GetSubTotal(viewModel.Products, currency);
// Reverse the list so the most recent products are first
viewModel.Products.Reverse();
return(View(viewModel));
}
ShoppingCart shoppingCart = new ShoppingCartManager().GetShoppingCartByUser(User.Identity.GetUserId());
viewModel.Products = new ShoppingCartProductManager().GetShoppingCartProductByShoppingCartId(shoppingCart.ShoppingCartId);
viewModel.Subtotal = ShoppingCartService.GetSubTotal(viewModel.Products, currency);
// Reverse the list so the most recent products are first
viewModel.Products.Reverse();
return(View(viewModel));
}
public void AddPyramidValuesByCoupon(CheckoutVM model)
{
var coupon = db.Coupons.First(c => c.CouponId == model.CouponId);
var pyramid = db.Pyramids.First(p => p.SiteUserId == coupon.SiteUserId);
SavePyramidValues(pyramid, model);
}
public void AddPyramidValuesToBP(CheckoutVM model, int customerId)
{
var customer = db.Customers.First(c => c.CustomerId == customerId);
var bp = db.BPs.First(b => b.BPId == customer.BPId);
var pyramid = db.Pyramids.First(p => p.SiteUserId == bp.SiteUserId);
SavePyramidValues(pyramid, model);
}
public ActionResult Payment()
{
//var checkout = Session["checkout"] as CheckOutDTO;
Mapper.Initialize(cfg => cfg.CreateMap <CheckOutDTO, CheckoutVM>());
CheckoutVM vm = Mapper.Map <CheckOutDTO, CheckoutVM>(checkout);
return(PartialView("_Payment", vm));
}
public void AddPyramidValuesRandom(CheckoutVM model)
{
var pyramid = db.Pyramids.Where(p => p.PyramidParentId == null).OrderBy(p => Guid.NewGuid()).FirstOrDefault();
if (pyramid != null)
{
SavePyramidValues(pyramid, model);
}
}
public ActionResult Pay(CheckoutVM model)
{
model.Countries = db.GetCountries();
CartVM cart = (CartVM)Session["Cart"];
model.Details = cart.Products;
model.DeliveryPrice = GetDeliveryPrice(model.DeliveryCountryId);
return(View(model));
}
public async Task <IActionResult> CheckoutAsync(CheckoutVM input)
{
int orderNum = await pService.PlaceOrderAsync(input);
pService.DeleteCart();
TempData["Message"] = $"{orderNum}";
return(RedirectToAction(nameof(CheckoutConfirmed)));
}
public IActionResult Edit(CheckoutVM checkoutVM, int Id)
{
var edit = _checkoutRepository.Edit(checkoutVM, Id);
if (edit > 0)
{
return(Ok(edit));
}
return(BadRequest("Can't be edited"));
}
public IActionResult Create(CheckoutVM checkoutVM)
{
var create = _checkoutRepository.Create(checkoutVM);
if (create > 0)
{
return(Ok(create));
}
return(BadRequest("Can't be created"));
}
public IActionResult Checkout(int id)
{
CheckoutVM model = new CheckoutVM();
model.incomesOfSharedBoats = db.IncomesOfSharedBoats.Include(c => c.Boat).Where(c => c.BoatID == id && c.IsCheckedOut == false).ToList();
model.Expenses = db.Expenses.Where(c => c.BoatID == id && c.IsCheckedOut == false).ToList();
ViewBag.BoatName = db.Boats.Find(id).BoatName;
ViewBag.BoatId = id;
return(View(model));
}
public PartialViewResult Addresses()
{
//var checkOut = Session["checkout"] as CheckOutDTO;
Mapper.Initialize(cfg => cfg.CreateMap <CheckOutDTO, CheckoutVM>());
CheckoutVM vm = Mapper.Map <CheckOutDTO, CheckoutVM>(checkout);
ViewBag.NoCost = Utils.GetValueCurrencyDisplay(Utils.getCurrencyName(CurrentCurrency, CurrentLanguage), 0);
return(PartialView("_UserAddresses", vm));
}
public int Create(CheckoutVM checkoutVM)
{
using (SqlConnection connection = new SqlConnection(_configuration.GetConnectionString("MyConnection")))
{
var procName = "SP_Insert_Checkout";
parameters.Add("receiptId", checkoutVM.receiptId);
var Insert = connection.Execute(procName, parameters, commandType: CommandType.StoredProcedure);
return(Insert);
}
}
public async Task <IActionResult> CheckoutPayment(CheckoutVM model)
{
//register the user and sign them in if they are not already signed in
ApplicationUser user = await CurrentUser();
if (user == null)
{
var userresult = await CreateUser(model);
if (userresult.HasErrors)
{
CheckoutErrorVM errorVM = new CheckoutErrorVM()
{
ErrorMessage = userresult.ErrorMessage
};
return(RedirectToAction("CheckoutError", errorVM));
}
else
{
//we now have a user
user = userresult.User;
}
}
//hook up with the stripe service and get the payment intent
//add this to the model and pass it on
model.Cart = _cart;
PaymentIntentResult result = await _stripeService.CreatePaymentIntent((model.Cart.Total * 100), model.Email);
//add the user to the courses but with the PaymentSucceeded set to false for now
//this is set when the webhook handles the payment success event
var useraddedresult = AddUserToCourses(user, result.PaymentIntentId);
if (!useraddedresult.Succeeded)
{
//we've been able to create the user but unable to add them to any courses
//this is highly unlikely but in this event we don't want them to go through
//to the payment form where the payment will be asked to be collected
//from stripe. So just send them to an error page
CheckoutErrorVM errorVM = new CheckoutErrorVM()
{
ErrorMessage = "There was a problem adding the user to the course(s). This may be a system problem. Please try again later."
};
return(RedirectToAction("CheckoutError", errorVM));
}
model.Cart.ClientSecret = result.ClientSecret;
model.PublishableKey = result.PublishableKey;
return(View(model));
}
public IActionResult Checkout()
{
var model = new CheckoutVM
{
CartItems = UnitOfWork.StoredProcedures.GetCartItemsInfo(SystemUser.Id),
OrderDeliveryTypes = UnitOfWork.OrderDeliveryTypes.FindAll(),
OrderPaymentTypes = UnitOfWork.OrderPaymentTypes.FindAll()
};
return(View(model));
}
private async Task <CheckoutUserResult> CreateUser(CheckoutVM model)
{
CheckoutUserResult userresult = new CheckoutUserResult();
var user = new ApplicationUser
{
UserName = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Company = model.Company,
Division = model.Division,
JobTitle = model.JobTitle,
Mobile = model.Mobile,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(nameof(AccountController.ConfirmEmail),
"Account",
new { userId = user.Id, code = code },
protocol: HttpContext.Request.Scheme);
await _emailSender.SendEmailAsync(model.Email,
"Confirm your account",
$"Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
await _signInManager.SignInAsync(user, isPersistent : false);
userresult.User = user;
}
else
{
IdentityError error = result.Errors.FirstOrDefault();
if (error.Code == "DuplicateUserName")
{
userresult.ErrorMessage = error.Description + " Please Log in to continue.";
}
else
{
userresult.ErrorMessage = "User could not be created" + error.Description;
}
userresult.HasErrors = true;
}
return(userresult);
}
private void SavePyramidValues(Pyramid pyramid, CheckoutVM model)
{
pyramid.PBV += model.SubTotal;
decimal sales = 0;
foreach (var p in model.Details)
{
sales += (0.23M - p.Discount) * p.Price * p.Quantity / 100M;
}
pyramid.SaleBonus += sales;
db.SaveChanges();
}
public IActionResult Checkout(int id)
{
var book = _books.GetById(id);
var model = new CheckoutVM()
{
BookId = id,
Title = book.Title,
PatronId = "",
IsCheckedOut = book.IsCheckouted
};
return(View(model));
}
public async Task <IActionResult> CheckoutUserInfo(CheckoutVM model)
{
//if user is logged in already then jump to the payment screen
ApplicationUser user = await CurrentUser();
if (user != null)
{
return(RedirectToAction("CheckoutPayment", model));
}
//pass the model into the view so we can collect the uer details
return(View(model));
}
public async Task <IActionResult> Checkout()
{
var productIds = Request.Cookies["CartProduct"];
CheckoutVM vm = new CheckoutVM();
if (productIds != null && !string.IsNullOrEmpty(productIds))
{
var ProIDs = productIds.Split('-').Select(p => int.Parse(p)).ToList();
vm.Products = _productService.FindProductIDs(ProIDs);
vm.K101User = await _userManager.GetUserAsync(User);
vm.ProductIds = ProIDs;
}
return(View(vm));
}
public async Task <IActionResult> Checkout(CheckoutVM model)
{
JsonResult jsonResult = new JsonResult(new { });
var productIds = Request.Cookies["CartProduct"];
if (productIds != null && !string.IsNullOrEmpty(productIds))
{
var ProIDs = productIds.Split('-').Select(p => int.Parse(p)).ToList();
model.Products = _productService.FindProductIDs(ProIDs);
model.ProductIds = ProIDs;
if (User.Identity.IsAuthenticated)
{
var newOrder = new Order();
newOrder.CustomerID = _userManager.GetUserId(User);
newOrder.CustomerName = model.FullName;
newOrder.CustomerEmail = model.Email;
newOrder.CustomerPhone = model.PhoneNumber;
newOrder.CustomerAddress = model.Address;
newOrder.OrderItems = new List <OrderItem>();
foreach (var product in model.Products)
{
var orderItem = new OrderItem()
{
ProductID = product.ID,
ProductName = product.Name,
ItemPrice = product.Price,
Quantity = ProIDs.Where(x => product.ID == x).Count()
};
newOrder.OrderItems.Add(orderItem);
newOrder.OrderCode = Guid.NewGuid().ToString();
newOrder.TotalAmmount = newOrder.OrderItems.Sum(x => (x.ItemPrice * x.Quantity));
newOrder.OrderHistory = new List <OrderHistory>()
{
OrderStatus = (int)OrderStatus.Placed,
ModifiedOn = DateTime.Now,
Note = "Order Placed."
};
newOrder.PlacedOn = DateTime.Now;
}
_context.Add(newOrder);
await _context.SaveChangesAsync();
}
}
Response.Cookies.Delete("CartProduct");
return(jsonResult);
}
public ActionResult SaveOrder(CheckoutVM model)
{
CartVM cart = (CartVM)Session["Cart"];
model.Details = cart.Products;
model.DeliveryPrice = GetDeliveryPrice(model.DeliveryCountryId);
if (!string.IsNullOrEmpty(cart.CouponUniqueId))
{
model.CouponId = db.GetCouponInfo(cart.CouponUniqueId).CouponId;
}
Session.Remove("Cart");
if (Session["CustomerId"] == null)
{
var customerData = db.CreateCustomer(model);
string content = System.IO.File.ReadAllText(Server.MapPath("/Mails/newuser.txt"));
content = content.Replace("{username}", model.CustomerEmail);
content = content.Replace("{password}", customerData.Password);
Parallel.Invoke(() =>
{
Common.Tools.Mailer.SendMailSpecific(content,
model.CustomerEmail,
"Your user is created");
});
Session["CustomerId"] = customerData.CustomerId;
Session["CustomerName"] = model.CustomerName;
}
model.CustomerId = (int)Session["CustomerId"];
db.SaveSale(model);
if (model.CouponId.HasValue)
{
db.AddPyramidValuesByCoupon(model);
}
else
if (Session["IsBP"] != null && (bool)Session["IsBP"])
{
db.AddPyramidValuesToBP(model, (int)Session["CustomerId"]);
}
else
{
db.AddPyramidValuesRandom(model);
}
return(RedirectToAction("Confirm", "Cart"));
}
// GET: /Cart/PlaceOrder
public ActionResult Checkout()
{
List <CartVM> cart = Session["cart"] as List <CartVM>;
decimal total = 0m;
if (cart == null)
{
// Create a TempData message
TempData["Checkout"] = "Your order has been recieved and is now being processed.";
return(View());
}
foreach (var item in cart)
{
total += item.Total;
}
ViewBag.GrandTotal = total;
ViewBag.CartVMList = cart;
// Get username
string username = User.Identity.Name;
if (string.IsNullOrEmpty(username))
{
ViewBag.IsAuthenticated = "false";
return(View());
}
else
{
CheckoutVM model;
using (Db db = new Db())
{
// Get user
UserModel dto = db.Users.FirstOrDefault(x => x.Username == username);
// Build model
model = new CheckoutVM(dto);
}
ViewBag.IsAuthenticated = "true";
return(View(model));
}
}
public IActionResult Checkout()
{
var productCookie = Request.Cookies["k207Cart"];
if (productCookie != null && productCookie.Length > 0)
{
List <int> productIds = productCookie.Split('-').Select(p => int.Parse(p)).ToList();
List <Product> products = _context.Products.Where(p => productIds.Contains(p.ID)).ToList();
CheckoutVM vm = new CheckoutVM()
{
Products = products,
ProductIds = productIds,
K207User = _userManager.GetUserAsync(User)
};
return(View(vm));
}
return(View());
}
