protected string GetBasketTotal()
{
var helper = new BasketHelper();
var total = helper.GetBasketTotal();
return(total.ToString("F"));
}
protected string GetBasketText()
{
var helper = new BasketHelper();
var basket = helper.GetBasket();
return(string.Format("My Basket ({0})", helper.GetProductCount()));
}
public async Task <IActionResult> OnPostAsync()
{
Animate = true;
Product = await _ds.GetProductByIdAsync(ProductId.Value);
BasketHelper.AddToBasket(HttpContext.Session, ProductId.Value, Product.CalculatedPrice, Number);
return(RedirectToPage("/Categories", new { CategoryId = CategoryId }));
}
public async Task OnGetAsync()
{
Basket = BasketHelper.GetBasket(HttpContext.Session);
Products = await _ds.GetProductsAsync();
MainLayout.ShoppingBasket = Basket;
ViewData["MainLayout"] = MainLayout;
}
private IList <BasketItem> GetBasketItems()
{
Basket basket = AbleContext.Current.User.Basket;
IBasketService preCheckoutService = AbleContext.Resolve <IBasketService>();
preCheckoutService.Combine(basket);
_DisplayedBasketItems = BasketHelper.GetDisplayItems(basket, false);
return(_DisplayedBasketItems);
}
protected void Page_PreRender(object sender, EventArgs e)
{
bool hasSubscriptions = BasketHelper.HasRecurringSubscriptions(AbleContext.Current.User.Basket);
bool newSubFeatureEnabled = AbleContext.Current.Store.Settings.ROCreateNewOrdersEnabled;
AmazonCheckoutWidget.Visible = AbleContext.Current.User.Basket.Items.Count > 0 &&
(!hasSubscriptions || !newSubFeatureEnabled) &&
HasAmazonGateway();
}
public async Task <IActionResult> OnPostAsync()
{
Animate = true;
Product = await _ds.GetProductByIdAsync(ProductId.Value);
BasketHelper.AddToBasket(HttpContext.Session, ProductId.Value, Product.CalculatedPrice, Number);
return(RedirectToPage("ProductDetails", new { ProductId = ProductId }));
// MainLayout.ShoppingBasket = BasketHelper.GetBasket(HttpContext.Session);
// ViewData["MainLayout"] = MainLayout;
}
protected void Page_Load(object sender, EventArgs e)
{
var helper = new BasketHelper();
rptOrderHistory.DataSource = helper.GetAllPurchasedProducts();
rptOrderHistory.DataBind();
rptCurrentOrders.DataSource = helper.GetAllProducts();
rptCurrentOrders.DataBind();
}
public async Task OnGetAsync()
{
if (ProductId != null)
{
Product = await _ds.GetProductByIdAsync(ProductId.Value);
ProductQuantity = await _ds.GetProductStockAsync(ProductId.Value);
}
MainLayout.ShoppingBasket = BasketHelper.GetBasket(HttpContext.Session);
ViewData["MainLayout"] = MainLayout;
}
public decimal CalculateTotalDeliveryPrice(BasketModel basket)
{
var deliveryPrice = _settings.CalculatorSettings.DeliveryPrice;
var basketDeliveryPrice = _settings.CalculatorSettings.BasketDeliveryPrice;
var productDeliveryPrice = _settings.CalculatorSettings.ProductDeliveryPrice;
var totalDelivery =
BasketHelper.CalculateDeliveryPrice(basket, deliveryPrice, basketDeliveryPrice, productDeliveryPrice);
return(totalDelivery);
}
protected void Page_Load(object sender, EventArgs e)
{
helper = new BasketHelper();
// Get basket based on tracker id
basket = helper.GetBasket();
if (basket != null)
{
rptProducts.DataSource = helper.GetAllProducts(basket);
rptProducts.DataBind();
}
}
protected decimal GetBasketSubtotal()
{
decimal basketTotal = 0;
IList <BasketItem> displayItems = BasketHelper.GetDisplayItems(AbleContext.Current.User.Basket, true, true);
foreach (BasketItem bi in displayItems)
{
basketTotal += InvoiceHelper.GetInvoiceExtendedPrice(bi);
}
return(basketTotal);
}
protected bool AllowPartialPayments()
{
bool allow = this.AllowAmountEntry || AbleContext.Current.Store.Settings.EnablePartialPaymentCheckouts;
// check if this order contain subscriptions
if (allow)
{
allow = !BasketHelper.HasRecurringSubscriptions(AbleContext.Current.User.Basket);
}
return(allow);
}
protected void Page_PreRender(object sender, System.EventArgs e)
{
// EXPRESS CHECKOUT BUTTON IS NOT VISIBLE BY DEFAULT
// DETERMINE WHETHER THE PAYPAL GATEWAY IS DEFINED, AND WHETHER IT HAS API SERVICES ENABLED
// BUTTON ONLY SHOWS IF PRODUCTS ARE IN THE BASKET AND MIN/MAX ORER LIMITS ARE MET
if (BasketHasProducts())
{
bool hasSubscriptions = BasketHelper.HasRecurringSubscriptions(AbleContext.Current.User.Basket);
bool newSubFeatureEnabled = AbleContext.Current.Store.Settings.ROCreateNewOrdersEnabled;
if (!hasSubscriptions || !newSubFeatureEnabled)
{
Basket basket = AbleContext.Current.User.Basket;
foreach (BasketItem item in basket.Items)
{
if (item.OrderItemType == OrderItemType.Product)
{
if (item.Product.IsProhibited)
{
this.Visible = false;
return;
}
}
}
// FIND THE PAYPAL GATEWAY
PayPalProvider provider = AbleCommerce.Code.StoreDataHelper.GetPayPalProvider();
if (provider != null && provider.ApiEnabled && ValidateOrderMinMaxAmounts())
{
//SHOW PANEL IF API ENABLED
ExpressCheckoutPanel.Visible = !AbleContext.Current.Store.Settings.ProductPurchasingDisabled;
if (ShowHeader)
{
phHeader.Visible = true;
}
else
{
phHeader.Visible = false;
}
if (ShowDescription)
{
phDescription.Visible = true;
}
else
{
phDescription.Visible = false;
}
phBillMeLaterBtn.Visible = provider.IsPayPalCreditEnabled;
}
}
}
}
public async Task OnGetAsync()
{
MainLayout.ShoppingBasket = BasketHelper.GetBasket(HttpContext.Session);
ViewData["MainLayout"] = MainLayout;
var userID = _um.GetUserId(User);
var q = await _ds.GetAllOrdersAsync();
Orders = q.Where(o => o.UserID == userID);
if (OrderId != 0)
{
Order = _ds.GetOrder(OrderId);
}
}
private IList <BasketItem> GetBasketItems()
{
Basket basket = AbleContext.Current.User.Basket;
if (!_Recalculated)
{
IBasketService preCheckoutService = AbleContext.Resolve <IBasketService>();
preCheckoutService.Recalculate(basket);
preCheckoutService.Combine(basket);
_Recalculated = true;
}
_DisplayedBasketItems = BasketHelper.GetDisplayItemsForInvoice(basket, false);
return(_DisplayedBasketItems);
}
protected void AddToCart_Click(object sender, EventArgs e)
{
var helper = new BasketHelper();
var basket = helper.GetBasket();
if (basket != null)
{
// TODO: This doesn't work if there's already a historical product..
helper.AddProductToBasket(basket, Sitecore.Context.Item.Name, 1);
}
var url = Sitecore.Web.WebUtil.GetRawUrl();
Response.Redirect(url + "?sc_trk={4BEEC42D-0349-4264-93E4-A14C4075CFEF}");
}
public ActionResult Order(PagePlusActivityPlusOrderDinners model)
{
Order order = (Order)Session["order"];
if (order == null)
{
order = new Order();
}
DateTime startTime = model.Day.Date + model.Time.TimeOfDay;
Activity activity = activityRepository.GetActivity(model.Activity.Id, (Language)Session["language"]);
OrderHasTickets ticketOrder = new OrderHasTickets();
ticketOrder.Ticket_TimeSlot_Activity_Id = model.Activity.Id;
ticketOrder.Remarks = model.Order.OrderHasTickets[0].Remarks;
ticketOrder.Ticket_TimeSlot_StartTime = model.Day.Date + model.Time.TimeOfDay;
ticketOrder.Ticket_Type = TicketType.Single;
ticketOrder.Amount = model.NumberOfAdults;
ticketOrder.Ticket = ticketRepository.GetTicket(activity, startTime, ticketOrder.Ticket_Type);
ticketOrder.TotalPrice = model.NumberOfAdults * ticketOrder.Ticket.Price;
order.OrderHasTickets.Add(ticketOrder);
if (model.NumberOfKids > 0)
{
OrderHasTickets to = new OrderHasTickets();
to.Ticket_TimeSlot_Activity_Id = model.Activity.Id;
to.Remarks = model.Order.OrderHasTickets[0].Remarks;
to.Ticket_TimeSlot_StartTime = model.Day.Date + model.Time.TimeOfDay;
to.Ticket_Type = TicketType.Child;
to.Amount = model.NumberOfKids;
to.Ticket = ticketRepository.GetTicket(activity, startTime, to.Ticket_Type);
to.TotalPrice = model.NumberOfKids * ticketOrder.Ticket.Price;
order.OrderHasTickets.Add(to);
}
Session["order"] = order;
BasketHelper.getInstance().checkBasket(HttpContext);
return(Redirect(ControllerContext.HttpContext.Request.UrlReferrer.ToString()));
}
protected void Page_PreRender(object sender, EventArgs e)
{
bool hasSubscriptions = BasketHelper.HasRecurringSubscriptions(AbleContext.Current.User.Basket);
bool newSubFeatureEnabled = AbleContext.Current.Store.Settings.ROCreateNewOrdersEnabled;
if (!hasSubscriptions || !newSubFeatureEnabled)
{
IPaymentProvider amazonProvider = GetAmazonProvider();
if (amazonProvider != null)
{
MethodInfo buttonMethod = amazonProvider.GetType().GetMethod("GetCheckoutButton");
object[] parameters = new object[] { AbleContext.Current.User.Basket };
PlaceHolder checkoutButton = (PlaceHolder)buttonMethod.Invoke(amazonProvider, parameters);
this.ButtonPanel.Controls.Add(checkoutButton);
}
}
}
public bool ApplyCampaignToBasket(Guid basketId, CampaignModel campaign)
{
var basket = GetBasket(basketId);
if (basket == null)
{
throw new ArgumentNullException("Basket is not found");
}
if (campaign != null && basket.Products.Count >= campaign.MinimumProductCount)
{
var affectedProductIds = BasketHelper.CheckCampaignInBasket(basket, campaign);
if (affectedProductIds.Any(a => a == Guid.Empty) || affectedProductIds.Count <= 0)
{
Console.WriteLine("{0} could not be applied", campaign.Title);
return(false);
}
foreach (var product in basket.Products)
{
var checkProduct = affectedProductIds.Any(a => a == product.Key.Id);
if (checkProduct && product.Key != null && product.Value > 0)
{
decimal campaignDiscount = decimal.Zero;
switch (campaign.Type)
{
case CampaignType.Rate:
campaignDiscount = (((product.Key.Price) * campaign.Amount) / 100) *
product.Value;
break;
case CampaignType.Total:
campaignDiscount = campaign.Amount * product.Value;
break;
}
basket.DiscountTotal += campaignDiscount;
}
}
basket.Campaigns.Add(campaign);
return(true);
}
Console.WriteLine("Campaign could not be applied. Please check campaign or product minimum count condition");
return(false);
}
public HttpResponseMessage checkOut()
{
try
{
BasketHelper.checkOut();
}
catch (Exception e)
{
var exResponse = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent("Cannot complete check out"),
ReasonPhrase = e.Message
};
throw new HttpResponseException(exResponse);
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
public async Task OnGetAsync()
{
MainLayout.ShoppingBasket = BasketHelper.GetBasket(HttpContext.Session);
ViewData["MainLayout"] = MainLayout;
Highlighted = await _ds.GetHighlightedProductsAsync();
OnSale = await _ds.GetProductsOnSaleAsync();
Latest = await _ds.GetLatestProductsAsync();
BestSellingProducts = _ds
.GetBestSellingProducts()
.Select(p => _ds
.GetProductById(p.ProductId));
}
public ActionResult Delete(int ohdId)
{
Order order = (Order)Session["order"];
foreach (var orderhasticket in order.OrderHasTickets)
{
if (orderhasticket.Ticket_TimeSlot_Activity_Id == ohdId)
{
order.OrderHasTickets.Remove(orderhasticket);
break;
}
}
Session["order"] = order;
BasketHelper.getInstance().checkBasket(HttpContext);
return(RedirectToAction("Basket"));
}
// PUT: api/Basket/5
public HttpResponseMessage Put(int id)
{
try
{
BasketHelper.UpdateCheckOut(id);
}
catch (Exception e)
{
var exResponse = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent("Cannot Update Item in Cart"),
ReasonPhrase = e.Message
};
throw new HttpResponseException(exResponse);
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
// POST: api/Basket
public HttpResponseMessage Post([FromBody] BasketItem item)
{
try
{
BasketHelper.AddToCart(item);
}
catch (Exception e)
{
var exResponse = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent("Cannot Add Item to cart"),
ReasonPhrase = e.Message
};
throw new HttpResponseException(exResponse);
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
private bool HasRecurringSubscriptions()
{
bool hasBasket = this.Basket != null;
bool hasOrder = this.Order != null;
if (hasBasket)
{
return(BasketHelper.HasRecurringSubscriptions(this.Basket));
}
else if (hasOrder)
{
return(OrderHelper.HasRecurringSubscriptions(this.Order));
}
else
{
return(false);
}
}
public async Task <IActionResult> OnGetCheckStockAsync()
{
Basket = BasketHelper.GetBasket(HttpContext.Session);
if (Basket.Items.Count == 0)
{
IsNotEmpty = false;
return(Page());
}
else
{
IsNotEmpty = true;
}
Basket = BasketHelper.GetBasket(HttpContext.Session);
foreach (var item in Basket.Items)
{
int stockBalance = await _ds.GetProductStockAsync(item.ProductId);
if (item.Quantity > stockBalance)
{
int length = item.Quantity - stockBalance;
for (int i = 0; i < length; i++)
{
BasketHelper.ModifyItem(HttpContext.Session, item.ProductId, false, false);
}
StockStatusOK = false;
StockStatusUpdated = true;
}
}
if (StockStatusOK)
{
return(RedirectToPage("/Checkout"));
}
Basket = BasketHelper.GetBasket(HttpContext.Session);
Products = await _ds.GetProductsAsync();
MainLayout.ShoppingBasket = Basket;
return(Page());
}
public static void UpdateSourceToBasket(bool isAffiliate = false, bool isUpgradeFlow = false)
{
//Update source, dealer number, dealer name in basket to display in confirmation pdf
var basketId = isUpgradeFlow ? BasketHelper.GetUpgradeBasketId() : BasketHelper.GetBasketId();
var loggedUserData = LoggedUser;
if (loggedUserData != null && IsDealerOrAgent)
{
var source = string.Empty;
var dealerId = new Guid();
var createdBy = loggedUserData.Name;
var createdName = loggedUserData.Name + " " + loggedUserData.Name;
if (IsDealer)
{
source = "Dealer";
var company = Configuration.ConfigurationHelper.**WsConfig.Company;
if (company != Company.TVVLAANDEREN && company != Company.TELESAT)
{
dealerId = GetDealerId(createdBy);
}
// This is only required for HDAustria for now. As we are yet to map the dealers to correct groups in TVV/TSAT for campaigns.
}
else if (IsAgent)
{
source = "Agent";
}
if (dealerId == new Guid())
{
dealerId = BasketHelper.GetDefaultDealerId();
}
var updateBasketInfo = new CreateBasketDTO
{
BasketId = basketId,
Source = source,
CreatedBy = createdBy,
CreatedName = (isAffiliate ? "Affiliate-" : string.Empty) + createdName,
DealerId = dealerId
};
**.ServiceBus.Extern.Basket.GetService().UpdateSourceToBasket(updateBasketInfo);
}
}
// GET: api/Basket
public HttpResponseMessage Get()
{
List <BasketItem> basketItems = null;
try
{
basketItems = BasketHelper.linqShoppingCart();
} catch (Exception e)
{
var exResponse = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent("Cannot get cart items"),
ReasonPhrase = e.Message
};
throw new HttpResponseException(exResponse);
}
return(Request.CreateResponse(HttpStatusCode.OK, basketItems));
}
public async Task <IActionResult> OnGetAsync(string toggleId = null)
{
if (!string.IsNullOrEmpty(toggleId))
{
Tags = AllergyTagHelper.LoadTags(HttpContext.Session);
var tag = Tags.FirstOrDefault(t => t.Value == toggleId);
tag.Selected = !tag.Selected;
AllergyTagHelper.SaveTags(HttpContext.Session, Tags);
return(RedirectToPage("./Categories", new { CategoryId = CategoryId }));
}
Categories = await _ds.GetProductCategoriesAsync();
Tags = AllergyTagHelper.LoadTags(HttpContext.Session);
if (Tags == null)
{
Tags = await _ds.GetTagsListAsync();
AllergyTagHelper.SaveTags(HttpContext.Session, Tags);
}
if (CategoryId != null)
{
Products = await _ds.GetProductsByCategoryAsync(CategoryId.Value);
CategoryName = Categories.FirstOrDefault(c => c.Id == CategoryId).Name;
if (CategoryName == "Färdiga paket")
{
Products = Products.OrderBy(o => o.Price);
}
}
else
{
var list = await _ds.GetProductsAsync();
Products = list.Where(c => c.Category.Name != "Färdiga paket").OrderBy(o => o.Name);
}
MainLayout.ShoppingBasket = BasketHelper.GetBasket(HttpContext.Session);
if (CategoryName != "Färdiga paket")
{
Products = _ds.FilteredProducts(Products, Tags);
}
ViewData["MainLayout"] = MainLayout;
return(Page());
}
