public decimal GetTax(CartItemData cartItemData)
{
// just multiply up if we're calculating individually
if (_taxSettings.TaxCalculationMethod == TaxCalculationMethod.Individual)
{
return(cartItemData.PricedQuantity * GetUnitTax(cartItemData));
}
//otherwise we start the logic based on the total here
if (!_taxSettings.TaxesEnabled)
{
return(decimal.Zero);
}
var productVariant = cartItemData.Item;
var priceBreak = GetPriceBreak(cartItemData);
var basePrice = priceBreak?.Price ?? productVariant.BasePrice;
var quantity = cartItemData.PricedQuantity;
var totalAmount = basePrice * quantity;
var taxRatePercentage = GetTaxRatePercentage(productVariant);
var discountAmount = cartItemData.UnitDiscountAmount * quantity;
return(GetTax(totalAmount, taxRatePercentage, discountAmount, cartItemData.DiscountPercentage));
}
public IActionResult AddToCart()
{
if (!IsUser())
{
return(View(login));
}
int cartID = new CartData().GetCartIDByUsername(HttpContext.Session.GetString("SessionUser"));
int quantity = int.Parse(Request.Form["txtQuantity"]);
int productDetailID = int.Parse(Request.Form["slProductDetail"]);
CartItemData cid = new CartItemData();
if (cid.AlreadyExistedInCart(cartID, productDetailID))
{
ViewBag.Announcement = "Product has already had in cart";
}
else
{
if (new CartItemData().InsertNewItemToCart(new CartItemDTO {
CartId = cartID, ProductDetailId = productDetailID, Quantity = quantity
}))
{
ViewBag.Announcement = "Add to cart successfully";
}
else
{
ViewBag.Announcement = "Add to cart failed";
}
}
ViewBag.Cart = new CartItemData().GetCartItemsByCartID(cartID);
return(View("Cart"));
}
public IActionResult Checkout()
{
if (!IsUser())
{
return(View(index));
}
bool check = true;
List <CartItemDTO> list = new List <CartItemDTO>();
string[] productDetailID = Request.Form["txtProductDetailID"];
string[] quantity = Request.Form["txtQuantity"];
int cartID = new CartData().GetCartIDByUsername(HttpContext.Session.GetString("SessionUser"));
for (int i = 0; i < productDetailID.Length; i++)
{
int pdID = int.Parse(productDetailID[i]);
int qtt = int.Parse(quantity[i]);
list.Add(new CartItemDTO {
CartId = cartID, Quantity = qtt, ProductDetailId = pdID
});
}
if (check = new CartItemData().CheckValidCartItems(list))
{
ViewBag.UserInfo = new UserData().GetUserInfoByUserID(HttpContext.Session.GetString("SessionUser"));
ViewBag.Cart = new CartItemData().GetCartItemsByCartID(cartID);
return(View());
}
else
{
ViewBag.Announcement = "Update failed";
}
ViewBag.Cart = new CartItemData().GetCartItemsByCartID(cartID);
return(View("Cart"));
}
public decimal GetPrice(CartItemData cartItemData)
{
// just multiply up if we're calculating individually
if (_taxSettings.TaxCalculationMethod == TaxCalculationMethod.Individual)
{
return(cartItemData.PricedQuantity * GetUnitPrice(cartItemData));
}
var productVariant = cartItemData.Item;
var quantity = cartItemData.PricedQuantity;
var priceBreak = GetPriceBreak(cartItemData);
var basePrice = priceBreak?.Price ?? productVariant.BasePrice;
var totalAmount = basePrice * quantity;
var taxRatePercentage = GetTaxRatePercentage(productVariant);
var discount = cartItemData.UnitDiscountAmount * quantity;
if (_taxSettings.PriceLoadingMethod == PriceLoadingMethod.IncludingTax)
{
return(GetPrice(totalAmount, taxRatePercentage, discount, cartItemData.DiscountPercentage));
}
var pricePreTax = GetPricePreTax(cartItemData);
var tax = GetTax(cartItemData);
return(pricePreTax + tax);
}
public decimal GetPricePreDiscount(CartItemData cartItemData)
{
// just copying the cart item without discount to get a pre discount price
return(GetPrice(new CartItemData
{
Item = cartItemData.Item,
Pricing = cartItemData.Pricing,
Quantity = cartItemData.Quantity,
}));
}
public void CartItem_Weight_ShouldBeWeightTimesQuantity()
{
A.CallTo(() => _productVariant.Weight).Returns(123);
var cartItem = new CartItemData {
Item = _productVariant, Quantity = 3
};
var weight = cartItem.Weight;
weight.Should().Be(369);
}
public static bool IsAbleToUseShippingMethod(this CartItemData item, IShippingMethod shippingMethod)
{
var productVariant = item.Item;
if (!productVariant.RequiresShipping)
{
return(true);
}
return(!productVariant.HasRestrictedShipping ||
productVariant.RestrictedTo.Contains(shippingMethod.TypeName));
}
public void Empty_RemovesItemsFromModel()
{
var cartItem = new CartItemData {
Item = _productVariant, Quantity = 1
};
_cartModel.Items.Add(cartItem);
_emptyBasket.Empty();
_cartModel.Items.Should().BeEmpty();
}
public void Empty_RemovesItemsFromDB()
{
var cartItem = new CartItemData {
Item = _productVariant, Quantity = 1
};
_cartModel.Items.Add(cartItem);
_emptyBasket.Empty();
Session.QueryOver <CartItem>().RowCount().Should().Be(0);
}
public static string GiftCardRecipient(this CartItemData item)
{
if (item == null || item.Item == null || !item.Item.IsGiftCard)
{
return(null);
}
var giftCardInfo = JsonConvert.DeserializeObject <GiftCardInfo>(item.Data);
if (giftCardInfo == null)
{
return(null);
}
return(giftCardInfo.RecipientName);
}
public decimal GetUnitTax(CartItemData cartItemData)
{
if (_taxSettings.TaxCalculationMethod == TaxCalculationMethod.Individual)
{
//return GetUnitTax(cartItemData.Item, cartItemData.UnitDiscountAmount, cartItemData.DiscountPercentage);
var unitPriceDiscountAmount = cartItemData.UnitDiscountAmount;
var discountPercentage = cartItemData.DiscountPercentage;
var priceBreak = GetPriceBreak(cartItemData);
return(priceBreak != null
? GetUnitTax(priceBreak, unitPriceDiscountAmount, discountPercentage)
: GetUnitTax(cartItemData.Item, unitPriceDiscountAmount, discountPercentage));
}
return(Math.Round(GetTax(cartItemData) / cartItemData.PricedQuantity, 2, MidpointRounding.AwayFromZero));
}
public void CartItem_GetDiscountAmount_IfNullDiscountIsPassedShouldBeZero()
{
var cartItem = new CartItemData
{
Item = _productVariant,
Quantity = 3,
Pricing = A.Fake <IProductPricingMethod>()
};
cartItem.SetDiscountAmount(0m);
var discountAmount = cartItem.DiscountAmount;
discountAmount.Should().Be(0);
}
public OrderLine GetOrderLine(CartItemData item)
{
var options = string.Join(", ", item.Item.OptionValues.Select(value => value.FormattedValue));
var orderLine = new OrderLine
{
UnitPrice = item.UnitPrice,
UnitPricePreTax = item.UnitPricePreTax,
Weight = item.Weight,
TaxRate = item.TaxRatePercentage,
Tax = item.Tax,
Quantity = item.Quantity,
ProductVariant = item.Item,
PricePreTax = item.PricePreTax,
Price = item.Price,
SKU = item.Item.SKU,
Name = item.Item.FullName,
Options = options,
Discount = item.DiscountAmount,
RequiresShipping = item.RequiresShipping,
Data = item.Data
};
if (item.IsDownloadable)
{
orderLine.IsDownloadable = true;
orderLine.AllowedNumberOfDownloads = item.AllowedNumberOfDownloads;
orderLine.DownloadExpiresOn =
(item.AllowedNumberOfDaysForDownload.HasValue && item.AllowedNumberOfDaysForDownload > 0)
? CurrentRequestData.Now.AddDays(
item.AllowedNumberOfDaysForDownload
.GetValueOrDefault())
: (DateTime?)null;
orderLine.NumberOfDownloads = 0;
var fileByUrl = _fileService.GetFileByUrl(item.DownloadFileUrl);
if (fileByUrl != null)
{
orderLine.DownloadFileUrl = fileByUrl.FileUrl;
orderLine.DownloadFileContentType = fileByUrl.ContentType;
orderLine.DownloadFileName = fileByUrl.FileName;
}
else
{
orderLine.DownloadFileUrl = item.DownloadFileUrl;
}
}
return(orderLine);
}
public CanBuyStatus CanBuy(CartItemData item)
{
var productVariant = item.Item;
var quantity = item.Quantity;
if (!_productStockChecker.IsInStock(productVariant))
{
return(new OutOfStock(productVariant));
}
var canOrderQuantityResult = _productStockChecker.CanOrderQuantity(productVariant, quantity);
if (!canOrderQuantityResult.CanOrder)
{
return(new CannotOrderQuantity(productVariant, canOrderQuantityResult.StockRemaining));
}
return(new CanBuy());
}
public CartItem MapToCartItem(CartItemData cartItemData)
{
if (cartItemData == null)
{
return(null);
}
var productData = Products.FirstOrDefault(product => product.Id == cartItemData.ProductId);
return(new CartItem
{
ProductId = cartItemData.ProductId,
ProductName = productData?.Name,
ProductDescription = productData?.Description,
ProductPrice = productData?.Price ?? 0,
Quantity = cartItemData.Quantity
});
}
private PriceBreak GetPriceBreak(CartItemData cartItemData)
{
return
(cartItemData.Item.PriceBreaks.OrderBy(x => x.Price)
.FirstOrDefault(x => x.Quantity <= cartItemData.Quantity));
}
public decimal GetUnitPricePreDiscount(CartItemData cartItemData)
{
return(GetUnitPrice(cartItemData.Item, 0, 0));
}
