public ActionResult AddToCart(Dictionary <string, string> item)
{
if (!item["culture"].IsNullOrEmpty())
{
Thread.CurrentThread.CurrentCulture = new CultureInfo(item["culture"]);
}
Product product_to_add = UvendiaContext.Products.Single <long>(long.Parse(item["p"]));
string size = item["size"];
if (product_to_add.HasVariant)
{
if (size.IsNullOrEmpty())
{
product_to_add = product_to_add.Variants.First();
}
else
{
product_to_add = product_to_add.Variants.First(x => string.Equals(x["Size"] as string, size, StringComparison.InvariantCultureIgnoreCase));
}
}
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
currentCart.AddProduct(product_to_add, int.Parse(item["qnty"]), SnuffoSettings.GetCurrency(), 0, item["thumb"]);
return(PartialView("~/views/partials/_CartShop.cshtml", new CartShopModel()));
}
public ActionResult CheckoutReviewPage(ContentModel model)
{
var crm = new CheckoutReviewModel(model.Content);
crm.CurrentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
crm.Order = crm.CurrentCart.GetOrder();
if (!crm.Order.PaymentMethodId.HasValue)
{
return(Redirect(string.Concat("/", CurrentUser.LanguageCode, "/cart/checkout-payment")));
}
crm.CartItems = crm.CurrentCart.GetCartItemsByCookieId();
var productIds = crm.CartItems.Where(c => c.ProductId.HasValue).Select(c => c.ProductId);
if (productIds.Any())
{
crm.Products = UvendiaContext.Products.All(productIds.ToArray());
}
var ticketSaleIds = crm.CartItems.Where(c => c.TicketSaleId.HasValue).Select(c => c.TicketSaleId);
if (ticketSaleIds.Any())
{
crm.TicketsSale = UvendiaContext.TicketSales.All(ticketSaleIds.ToArray());
}
return(CurrentTemplate(crm));
}
public ActionResult BuyTickets(EventDetailModel model, string imageId)
{
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
var tickets = model.Event.TicketsSale.ToList();
model.Event.LazyLoadProperties();
for (int i = 0; i < tickets.Count; i++)
{
string dropdownName = string.Concat("TicketType", i);
int ticketsQuantityToBuy = !Request.Form[dropdownName].IsNullOrEmpty() ? int.Parse(Request.Form[dropdownName]) : 0;
ViewData[dropdownName] = ticketsQuantityToBuy;
if (ticketsQuantityToBuy > 0)
{
currentCart.AddTicket(
tickets[i].Id,
model.Event.DisplayName(),
ticketsQuantityToBuy,
metaData: imageId);
}
}
return(Redirect($"/{CurrentUser.LanguageCode}/cart/"));
}
public ActionResult CartPage(ContentModel model)
{
var cartModel = new CartPageModel();
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
cartModel.CartItems = currentCart.GetCartItemsByCookieId().OrderBy(c => c.Name).ToList();
if (!cartModel.CartItems.IsNullOrEmpty())
{
var productIds = cartModel.CartItems.Where(c => c.ProductId.HasValue).Select(c => c.ProductId);
if (productIds.Any())
{
cartModel.Products = UvendiaContext.Products.All(productIds.ToArray()).ToList();
}
var ticketSaleIds = cartModel.CartItems.Where(c => c.TicketSaleId.HasValue).Select(c => c.TicketSaleId);
if (ticketSaleIds.Any())
{
cartModel.TicketsSale = UvendiaContext.TicketSales.All(ticketSaleIds.ToArray()).ToList();
}
cartModel.Subtotal = currentCart.CalculateSubtotal(cartModel.CartItems);
}
var checkoutUrl = $"/{CurrentUser.LanguageCode}/cart/checkout-address/";
cartModel.CheckoutUrl = (!CurrentUser.IsAuthenticated)
? $"/{CurrentUser.LanguageCode}/cart/checkout-login/?returnUrl={checkoutUrl}"
: checkoutUrl;
return(CurrentTemplate(cartModel));
}
public ActionResult ClearCart()
{
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
currentCart.ClearCart();
return(PartialView("~/views/partials/_CartShop.cshtml", new CartShopModel()));
}
public ActionResult RemoveFromCart(Guid ci)
{
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
currentCart.DeleteCartItem(ci);
currentCart.UpdateCartQuantityCount();
return(PartialView("~/views/partials/_CartShop.cshtml", new CartShopModel()));
}
public ActionResult CheckoutPaymentPage(ContentModel model)
{
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
var order = currentCart.GetOrder();
if (order.HasOrderProductDetails() && !order.ShippingMethodId.HasValue)
{
return(Redirect(string.Concat("/", CurrentUser.LanguageCode, "/cart/checkout-shipping")));
}
var cpm = new CheckoutPaymentModel(model.Content);
cpm.PaymentMethods = UvendiaContext.PaymentMethods.All().Where(p => p.Enabled).ToList();
cpm.SelectedPaymentMethodId = order.PaymentMethodId;
cpm.iDealIssuerId = order.MetaData;
try
{
var ideal = cpm.PaymentMethods.Single(x => x.Name.Equals("ideal", StringComparison.InvariantCultureIgnoreCase));
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
Connector connector = new Connector();
connector.MerchantId = ideal["MerchantID"];
connector.SubId = ideal["SubID"];
connector.ExpirationPeriod = ideal["ExpirationPeriod"];
connector.MerchantReturnUrl = new Uri(string.Format(ideal["MerchantReturnURL"], CurrentUser.LanguageCode));
ING.iDealAdvanced.Data.Issuers issuers = connector.GetIssuerList();
foreach (var country in issuers.Countries)
{
foreach (var issuer in country.Issuers)
{
cpm.iDealIssuerList.Add(new SelectListItem()
{
Text = issuer.Name, Value = issuer.Id.ToString()
});
}
}
}
catch (ING.iDealAdvanced.Data.IDealException iex)
{
// request consumerMessage
MailController.Instance(Request, model.Content, CurrentUser.LanguageCode).MailError(new HandleErrorInfo(iex, "CheckoutPaymentPage", "LoadIssueList")).SendAsync();
}
catch (Exception ex)
{
MailController.Instance(Request, model.Content, CurrentUser.LanguageCode).MailError(new HandleErrorInfo(ex, "CheckoutPaymentPage", "LoadIssueList")).SendAsync();
//throw;
}
return(CurrentTemplate(cpm));
}
public ActionResult UpdateCart(CartPageModel model)
{
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
foreach (var item in model.CartItems)
{
currentCart.UpdateQuantity(item.Id, item.Quantity);
}
currentCart.UpdateCartQuantityCount();
return(Redirect($"/{CurrentUser.LanguageCode}/cart"));
}
public ActionResult UpdateOrderCheckoutShipping(CheckoutShippingModel model)
{
if (ModelState.IsValid)
{
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
var order = currentCart.GetOrder();
order.ShippingMethodId = model.SelectedShippingMethodId.Value;
currentCart.SaveOrder(order);
return(Redirect($"/{CurrentUser.LanguageCode}/cart/checkout-payment"));
}
return(CurrentUmbracoPage());
}
public ActionResult LanguageCurrencySelect(LanguageCurrencySelectModel model)
{
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
if (!currentCart.HasCartItems())
{
SnuffoSettings.SetCurrency(model.SelectedCurrency);
}
else
{
base.ShowAlertMessage("Multiple Currencies Detected", "It is not allowed to add multiple type of currencies to your shopping cart", AlertMessageType.Error);
}
return(CurrentUmbracoPage());
}
public ActionResult CheckoutShippingPage(ContentModel model)
{
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
var order = currentCart.GetOrder();
if (!order.InvoiceAddressId.HasValue)
{
return(Redirect(string.Concat("/", CurrentUser.LanguageCode, "/cart/checkout-address")));
}
var csm = new CheckoutShippingModel(model.Content);
csm.ShippingMethods = UvendiaContext.ShippingMethods.All().Where(s => s.Enabled).ToList();
csm.SelectedShippingMethodId = order.ShippingMethodId;
return(CurrentTemplate(csm));
}
public CartShopModel()
{
CurrentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
if (CurrentCart.HasCartItems())
{
var items = CurrentCart.GetCartItemsByCookieId();
if (!items.IsNullOrEmpty())
{
CartItems = items.OrderBy(c => c.Name);
var productIds = items.Select(x => x.ProductId);
Subtotal = items.Sum(x => (x.Quantity * x.UnitPrice));
}
var checkoutUrl = $"/{CurrentUser.LanguageCode}/cart/checkout-address/";
CheckoutUrl = (!CurrentUser.IsAuthenticated)
? $"/{CurrentUser.LanguageCode}/cart/checkout-login/?returnUrl={checkoutUrl}"
: checkoutUrl;
}
}
public static string GetCurrency()
{
var cookie = HttpContext.Current.Request.Cookies[SELECTED_CURRENCY_COOKIE_NAME];
if (cookie == null)
{
var currentCart = CurrentCart.Create(STORE_NAME);
if (currentCart.ItemsCount > 0)
{
var order = currentCart.GetOrder();
var currency = order.GetOrderCurrency();
if (!currency.IsNullOrEmpty())
{
SetCurrency(currency);
return(currency);
}
}
}
return(cookie != null ? cookie.Value : "EUR");
}
public ActionResult CheckoutLoginPage(ContentModel model)
{
var authModel = new AuthenticateModel(model.Content);
authModel.ReturnUrl = Request.QueryString["returnUrl"];
authModel.Authenticated = CurrentUser.IsAuthenticated;
if (!authModel.Authenticated)
{
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
var order = currentCart.GetOrder();
if (order.InvoiceAddressId.HasValue)
{
return(Redirect(string.Concat("/", CurrentUser.LanguageCode, "/cart/checkout-address/")));
}
}
return(CurrentTemplate(authModel));
}
public ActionResult UpdateOrderCheckoutPayment(CheckoutPaymentModel model)
{
PaymentMethod paymentMethod = null;
if (model.SelectedPaymentMethodId.HasValue)
{
paymentMethod = UvendiaContext.PaymentMethods.Single(model.SelectedPaymentMethodId.Value);
if (model.SelectedPaymentMethodId.HasValue)
{
if (string.Equals(paymentMethod.Name, "ideal", StringComparison.InvariantCultureIgnoreCase) &&
model.iDealIssuerId.IsNullOrEmpty())
{
ModelState.AddModelError("", "Please select your bank");
}
}
}
if (ModelState.IsValid)
{
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
var order = currentCart.GetOrder();
order.PaymentMethod = paymentMethod;
order.PaymentMethodId = model.SelectedPaymentMethodId.Value;
order.MetaData = model.iDealIssuerId;
if (currentCart.SaveOrder(order, true, out List <string> errors))
{
return(Redirect($"/{CurrentUser.LanguageCode}/cart/checkout-review"));
}
else
{
errors.ForEach(err => ModelState.AddModelError("", err));
}
}
return(CurrentUmbracoPage());
}
public ActionResult UpdateOrderCheckoutAddress(AccountAddressModel model)
{
model.ContactAddress.AddressTypeId = AddressType.Default.Id;
model.ContactAddress.FirstName = model.FirstName;
model.ContactAddress.LastName = model.LastName;
model.ContactAddress.Email = model.EmailAddress;
model.ContactAddress.Phone = model.Phone;
base.SuppressValidation(model.GetPropertyName(x => x.ContactAddress.Phone));
base.SuppressValidation(model.GetPropertyName(x => x.ContactAddress.AddressTypeId));
base.SuppressValidation(model.GetPropertyName(x => x.ShippingAddress.AddressTypeId));
base.SuppressValidation(model.GetPropertyName(x => x.ShippingAddress.Phone));
if (model.ShippingAddress != null)
{
model.ShippingAddress.AddressTypeId = AddressType.ShipAddress.Id;
}
if (model.HasSameAddress)
{
base.SuppressValidation(model.GetPropertyName(x => x.ShippingAddress));
model.ShippingAddress = null;
}
if (!CurrentUser.IsAuthenticated)
{
base.SuppressValidation(model.GetPropertyName(x => x.UserId));
}
else
{
if (model.HasSameAddress)
{
UvendiaContext.Addresses.DeleteByUseryIdAndAddressType(CurrentUser.UserId, AddressType.ShipAddress);
}
}
if (ModelState.IsValid)
{
// Save user data
if (CurrentUser.IsAuthenticated)
{
_auth0Helper.UpdateAuth0User(model);
}
model.ContactAddress.CreatedBy = CurrentUser.UserId;
var addresses = new List <Address>()
{
model.ContactAddress
};
if (model.ShippingAddress != null)
{
model.ShippingAddress.CreatedBy = CurrentUser.UserId;
model.ShippingAddress.Phone = model.ContactAddress.Phone;
addresses.Add(model.ShippingAddress);
}
UvendiaContext.Addresses.Save(addresses);
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
var order = currentCart.GetOrder();
// Attach address to order
var invoiceAddress = addresses.Single(a => a.AddressTypeId == AddressType.Default.Id);
order.InvoiceAddressId = invoiceAddress.Id;
order.ShipAddressId = (model.ShippingAddress == null) ? (long?)null : addresses.Single(a => a.AddressTypeId != AddressType.Default.Id).Id;
// Save the order
currentCart.SaveOrder(order);
if (order.HasOrderProductDetails())
{
return(Redirect($"/{CurrentUser.LanguageCode}/cart/checkout-shipping"));
}
else
{
return(Redirect($"/{CurrentUser.LanguageCode}/cart/checkout-payment"));
}
}
return(CurrentUmbracoPage());
}
public ActionResult CheckoutCompletedPage(ContentModel model)
{
var currentCart = CurrentCart.Create(SnuffoSettings.STORE_NAME);
if (currentCart.ItemsCount == 0)
{
return(Redirect($"/{CurrentUser.LanguageCode}/cart/"));
}
try
{
var order = currentCart.GetOrder();
var checkoutOrder = OrderMapper.Map <CheckoutOrder>(order);
string baseUrl = WebUtils.GetApplicationUrlPath(HttpContext.ApplicationInstance.Context);
checkoutOrder.CallBackUrlOnPaymentSucceed = $"{baseUrl}{CurrentUser.LanguageCode}/checkout-completed";
checkoutOrder.CallBackUrlOnPaymentFailed = $"{baseUrl}{CurrentUser.LanguageCode}/checkout-cancelled";
checkoutOrder.OrderDetails.AddRange(OrderMapper.Map <List <CheckoutOrderDetail> >(order.ProductOrderDetails));
checkoutOrder.OrderDetails.AddRange(OrderMapper.Map <List <CheckoutOrderDetail> >(order.TicketOrderDetails));
var payment = PaymentBase.CreatePayment(checkoutOrder);
if (payment.PaymentMethod == CS.PaymentMethod.PayPal)
{
PayPalPayment paypal = payment as PayPalPayment;
paypal.IsSandbox = string.Equals(order.PaymentMethod["Mode"], "sandbox");
paypal.ClientId = order.PaymentMethod["ClientId"];
paypal.ClientSecret = order.PaymentMethod["ClientSecret"];
}
if (Request.QueryString.Count == 0)
{
var response = payment.DoPayment();
order.PaymentTransactionId = response.PaymentTransactionId;
// Save the order
currentCart.SaveOrder(order);
return(Redirect(response.PaymentServiceUrl));
}
order.PayerId = Request.QueryString["PayerID"];
if (payment.RequestPaymentStatus(order.PaymentTransactionId, order.PayerId, out string message) != PaymentStatus.Success)
{
order.PaymentError = message;
// Save order
order.OrderStatusId = OrderStatus.Cancelled.Id;
currentCart.SaveOrder(order);
return(Redirect($"/{CurrentUser.LanguageCode}/checkout-cancelled/"));
}
// Tickets are sent immediately
order.OrderStatusId = (order.ProductOrderDetails.IsNullOrEmpty()) ? OrderStatus.Sent.Id : OrderStatus.Started.Id;
order.Paid = true;
order.PaidAmount = order.CalculateTotal();
currentCart.CompleteOrder(order);
if (order.ProductOrderDetails.Any())
{
// Send order confirmation mail.
MailController.Instance(Request, model.Content, CurrentUser.LanguageCode).ConfirmOrderMail(order).Send();
}
if (order.TicketOrderDetails.Any()) // tickets bought
{
MailController.Instance(Request, model.Content, CurrentUser.LanguageCode).SendTicketsPDF(order).Send();
}
}
catch (OrderAlreadyProcessedException)
{
// Clear cart.
currentCart.ClearCart();
}
return(CurrentTemplate(model));
}
