public void Can_get_shopping_cart_item_unitPrice()
{
//customer
var customer = new Customer();
//shopping cart
var product1 = new Product
{
Id = 1,
Name = "Product name 1",
Price = 12.34M,
CustomerEntersPrice = false,
Published = true,
};
var sci1 = new ShoppingCartItem
{
Customer = customer,
CustomerId = customer.Id,
Product = product1,
ProductId = product1.Id,
Quantity = 2,
};
_discountService.Expect(ds => ds.GetAllDiscountsForCaching(DiscountType.AssignedToCategories)).Return(new List <DiscountForCaching>());
_discountService.Expect(ds => ds.GetAllDiscountsForCaching(DiscountType.AssignedToManufacturers)).Return(new List <DiscountForCaching>());
_priceCalcService.GetUnitPrice(sci1).ShouldEqual(12.34);
}
public void Can_get_shopping_cart_item_unitPrice()
{
//customer
var customer = new Customer();
//shopping cart
var product1 = new Product
{
Id = 1,
Name = "Product name 1",
Price = 12.34M,
CustomerEntersPrice = false,
Published = true,
};
var sci1 = new ShoppingCartItem()
{
Customer = customer,
CustomerId = customer.Id,
Product = product1,
ProductId = product1.Id,
Quantity = 2,
};
var item = new OrganizedShoppingCartItem(sci1);
_priceCalcService.GetUnitPrice(item, false).ShouldEqual(12.34);
}
public async Task <ProductDetailsAttributeChangeModel> Handle(GetProductDetailsAttributeChange request, CancellationToken cancellationToken)
{
var model = new ProductDetailsAttributeChangeModel();
string attributeXml = await _mediator.Send(new GetParseProductAttributes()
{
Product = request.Product, Form = request.Form
});
string warehouseId = _shoppingCartSettings.AllowToSelectWarehouse ?
request.Form["WarehouseId"].ToString() :
request.Product.UseMultipleWarehouses ? request.Store.DefaultWarehouseId :
(string.IsNullOrEmpty(request.Store.DefaultWarehouseId) ? request.Product.WarehouseId : request.Store.DefaultWarehouseId);
//rental attributes
DateTime?rentalStartDate = null;
DateTime?rentalEndDate = null;
if (request.Product.ProductType == ProductType.Reservation)
{
request.Product.ParseReservationDates(request.Form, out rentalStartDate, out rentalEndDate);
}
model.Sku = request.Product.FormatSku(attributeXml, _productAttributeParser);
model.Mpn = request.Product.FormatMpn(attributeXml, _productAttributeParser);
model.Gtin = request.Product.FormatGtin(attributeXml, _productAttributeParser);
if (await _permissionService.Authorize(StandardPermissionProvider.DisplayPrices) && !request.Product.CustomerEntersPrice && request.Product.ProductType != ProductType.Auction)
{
//we do not calculate price of "customer enters price" option is enabled
var unitprice = await _priceCalculationService.GetUnitPrice(request.Product,
request.Customer,
ShoppingCartType.ShoppingCart,
1, attributeXml, (decimal?)default,
public void Can_get_shopping_cart_item_unitPrice()
{
var customer001 = new Customer {
Id = "98767"
};
tempWorkContext.Setup(x => x.CurrentCustomer).Returns(customer001);
var product001 = new Product
{
Id = "242422",
Name = "product name 01",
Price = 49.99M,
CustomerEntersPrice = false,
Published = true,
};
tempProductService.Setup(x => x.GetProductById("242422")).Returns(product001);
var shoppingCartItem = new ShoppingCartItem
{
ProductId = "242422",// product001.Id, //222
Quantity = 2
};
customer001.ShoppingCartItems.Add(shoppingCartItem);
tempDiscountServiceMock.Setup(x => x.GetAllDiscounts(DiscountType.AssignedToCategories, "", "", false)).Returns(new List <Discount>());
tempDiscountServiceMock.Setup(x => x.GetAllDiscounts(DiscountType.AssignedToManufacturers, "", "", false)).Returns(new List <Discount>());
tempDiscountServiceMock.Setup(x => x.GetAllDiscounts(DiscountType.AssignedToAllProducts, "", "", false)).Returns(new List <Discount>());
Assert.AreEqual(49.99M, _priceCalcService.GetUnitPrice(shoppingCartItem));
}
/// <summary>
/// Prepare paged shopping cart item list model
/// </summary>
/// <param name="searchModel">Shopping cart item search model</param>
/// <param name="customer">Customer</param>
/// <returns>Shopping cart item list model</returns>
public virtual ShoppingCartItemListModel PrepareShoppingCartItemListModel(ShoppingCartItemSearchModel searchModel, Customer customer)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
if (customer == null)
{
throw new ArgumentNullException(nameof(customer));
}
//get shopping cart items
var items = customer.ShoppingCartItems.Where(item => item.ShoppingCartType == searchModel.ShoppingCartType).ToList();
//prepare list model
var model = new ShoppingCartItemListModel
{
Data = items.PaginationByRequestModel(searchModel).Select(item =>
{
//fill in model values from the entity
var itemModel = new ShoppingCartItemModel
{
Id = item.Id,
ProductId = item.ProductId,
Quantity = item.Quantity,
ProductName = item.Product?.Name
};
//convert dates to the user time
itemModel.UpdatedOn = _dateTimeHelper.ConvertToUserTime(item.UpdatedOnUtc, DateTimeKind.Utc);
//fill in additional values (not existing in the entity)
itemModel.Store = _storeService.GetStoreById(item.StoreId)?.Name ?? "Deleted";
itemModel.AttributeInfo = _productAttributeFormatter.FormatAttributes(item.Product, item.AttributesXml, item.Customer);
var unitPrice = _priceCalculationService.GetUnitPrice(item);
itemModel.UnitPrice = _priceFormatter.FormatPrice(_taxService.GetProductPrice(item.Product, unitPrice, out var _));
var subTotal = _priceCalculationService.GetSubTotal(item);
itemModel.Total = _priceFormatter.FormatPrice(_taxService.GetProductPrice(item.Product, subTotal, out _));
return(itemModel);
}),
Total = items.Count
};
return(model);
}
#endregion
}
/// <summary>
/// Prepare paged shopping cart item list model
/// </summary>
/// <param name="searchModel">Shopping cart item search model</param>
/// <param name="customer">Customer</param>
/// <returns>Shopping cart item list model</returns>
public virtual ShoppingCartItemListModel PrepareShoppingCartItemListModel(ShoppingCartItemSearchModel searchModel, Customer customer)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
if (customer == null)
{
throw new ArgumentNullException(nameof(customer));
}
//get shopping cart items
var items = _shoppingCartService.GetShoppingCart(customer, searchModel.ShoppingCartType,
searchModel.StoreId, searchModel.ProductId, searchModel.StartDate, searchModel.EndDate).ToPagedList(searchModel);
//prepare list model
var model = new ShoppingCartItemListModel().PrepareToGrid(searchModel, items, () =>
{
return(items.Select(item =>
{
//fill in model values from the entity
var itemModel = item.ToModel <ShoppingCartItemModel>();
//convert dates to the user time
itemModel.UpdatedOn = _dateTimeHelper.ConvertToUserTime(item.UpdatedOnUtc, DateTimeKind.Utc);
//fill in additional values (not existing in the entity)
itemModel.Store = _storeService.GetStoreById(item.StoreId)?.Name ?? "Deleted";
itemModel.AttributeInfo = _productAttributeFormatter.FormatAttributes(item.Product, item.AttributesXml, item.Customer);
var unitPrice = _priceCalculationService.GetUnitPrice(item);
itemModel.UnitPrice = _priceFormatter.FormatPrice(_taxService.GetProductPrice(item.Product, unitPrice, out var _));
var subTotal = _priceCalculationService.GetSubTotal(item);
itemModel.Total = _priceFormatter.FormatPrice(_taxService.GetProductPrice(item.Product, subTotal, out _));
//set product name since it does not survive mapping
itemModel.ProductName = item?.Product?.Name;
return itemModel;
}));
});
public PaymentDetailsItemType CreatePaymentItem(ShoppingCartItem item)
{
var productPrice = _taxService.GetProductPrice(item.Product,
_priceCalculationService.GetUnitPrice(item), false,
_workContext.CurrentCustomer, out _);
var currencyCodeType = _payPalCurrencyCodeParser.GetCurrencyCodeType(_workContext.WorkingCurrency);
var paymentDetailsItemType = new PaymentDetailsItemType
{
Name = item.Product.Name,
//Description = _productAttributeFormatter.FormatAttributes(item.ProductVariant, item.AttributesXml),
Amount = productPrice.GetBasicAmountType(currencyCodeType),
ItemCategory =
item.Product.IsDownload
? ItemCategoryType.Digital
: ItemCategoryType.Physical,
Quantity = item.Quantity.ToString()
};
return(paymentDetailsItemType);
}
/// <summary>
/// Create items from shopping cart
/// </summary>
/// <param name="shoppingCart">Shopping cart</param>
/// <returns>Collection of PayPal items</returns>
protected IEnumerable <Item> CreateItems(IEnumerable <ShoppingCartItem> shoppingCart)
{
return(shoppingCart.Select(shoppingCartItem =>
{
if (shoppingCartItem.Product == null)
{
return null;
}
var item = new Item
{
//name
name = shoppingCartItem.Product.Name
};
//SKU
if (!string.IsNullOrEmpty(shoppingCartItem.AttributesXml))
{
var combination = _productAttributeParser.FindProductAttributeCombination(shoppingCartItem.Product, shoppingCartItem.AttributesXml);
item.sku = combination != null && !string.IsNullOrEmpty(combination.Sku) ? combination.Sku : shoppingCartItem.Product.Sku;
}
else
{
item.sku = shoppingCartItem.Product.Sku;
}
//item price
var unitPrice = _priceCalculationService.GetUnitPrice(shoppingCartItem);
var price = _taxService.GetProductPrice(shoppingCartItem.Product, unitPrice, false, shoppingCartItem.Customer, out decimal _);
item.price = price.ToString("N", new CultureInfo("en-US"));
//quantity
item.quantity = shoppingCartItem.Quantity.ToString();
return item;
}));
}
public async Task <WishlistModel> Handle(GetWishlist request, CancellationToken cancellationToken)
{
var model = new WishlistModel();
model.EmailWishlistEnabled = _shoppingCartSettings.EmailWishlistEnabled;
model.IsEditable = request.IsEditable;
model.DisplayAddToCart = await _permissionService.Authorize(StandardPermissionProvider.EnableShoppingCart);
model.DisplayTaxShippingInfo = _catalogSettings.DisplayTaxShippingInfoWishlist;
if (!request.Cart.Any())
{
return(model);
}
#region Simple properties
model.CustomerGuid = request.Customer.CustomerGuid;
model.CustomerFullname = request.Customer.GetFullName();
model.ShowProductImages = _shoppingCartSettings.ShowProductImagesOnWishList;
model.ShowSku = _catalogSettings.ShowSkuOnProductDetailsPage;
//cart warnings
var cartWarnings = await _shoppingCartService.GetShoppingCartWarnings(request.Cart, "", false);
foreach (var warning in cartWarnings)
{
model.Warnings.Add(warning);
}
#endregion
#region Cart items
foreach (var sci in request.Cart)
{
var product = await _productService.GetProductById(sci.ProductId);
var cartItemModel = new WishlistModel.ShoppingCartItemModel {
Id = sci.Id,
Sku = product.FormatSku(sci.AttributesXml, _productAttributeParser),
ProductId = product.Id,
ProductName = product.GetLocalized(x => x.Name, request.Language.Id),
ProductSeName = product.GetSeName(request.Language.Id),
Quantity = sci.Quantity,
AttributeInfo = await _productAttributeFormatter.FormatAttributes(product, sci.AttributesXml),
};
//allow editing?
//1. setting enabled?
//2. simple product?
//3. has attribute or gift card?
//4. visible individually?
cartItemModel.AllowItemEditing = _shoppingCartSettings.AllowCartItemEditing && product.ProductType == ProductType.SimpleProduct && (!String.IsNullOrEmpty(cartItemModel.AttributeInfo) || product.IsGiftCard) && product.VisibleIndividually;
//allowed quantities
var allowedQuantities = product.ParseAllowedQuantities();
foreach (var qty in allowedQuantities)
{
cartItemModel.AllowedQuantities.Add(new SelectListItem {
Text = qty.ToString(),
Value = qty.ToString(),
Selected = sci.Quantity == qty
});
}
//recurring info
if (product.IsRecurring)
{
cartItemModel.RecurringInfo = string.Format(_localizationService.GetResource("ShoppingCart.RecurringPeriod"), product.RecurringCycleLength, product.RecurringCyclePeriod.GetLocalizedEnum(_localizationService, request.Language.Id));
}
//unit prices
if (product.CallForPrice)
{
cartItemModel.UnitPrice = _localizationService.GetResource("Products.CallForPrice");
}
else
{
var productprice = await _taxService.GetProductPrice(product, (await _priceCalculationService.GetUnitPrice(sci)).unitprice);
decimal taxRate = productprice.taxRate;
decimal shoppingCartUnitPriceWithDiscountBase = productprice.productprice;
decimal shoppingCartUnitPriceWithDiscount = await _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartUnitPriceWithDiscountBase, request.Currency);
cartItemModel.UnitPrice = _priceFormatter.FormatPrice(shoppingCartUnitPriceWithDiscount);
}
//subtotal, discount
if (product.CallForPrice)
{
cartItemModel.SubTotal = _localizationService.GetResource("Products.CallForPrice");
}
else
{
//sub total
var subtotal = await _priceCalculationService.GetSubTotal(sci, true);
decimal shoppingCartItemDiscountBase = subtotal.discountAmount;
List <AppliedDiscount> scDiscounts = subtotal.appliedDiscounts;
var productprices = await _taxService.GetProductPrice(product, subtotal.subTotal);
decimal taxRate = productprices.taxRate;
decimal shoppingCartItemSubTotalWithDiscountBase = productprices.productprice;
decimal shoppingCartItemSubTotalWithDiscount = await _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartItemSubTotalWithDiscountBase, request.Currency);
cartItemModel.SubTotal = _priceFormatter.FormatPrice(shoppingCartItemSubTotalWithDiscount);
//display an applied discount amount
if (shoppingCartItemDiscountBase > decimal.Zero)
{
shoppingCartItemDiscountBase = (await _taxService.GetProductPrice(product, shoppingCartItemDiscountBase)).productprice;
if (shoppingCartItemDiscountBase > decimal.Zero)
{
decimal shoppingCartItemDiscount = await _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartItemDiscountBase, request.Currency);
cartItemModel.Discount = _priceFormatter.FormatPrice(shoppingCartItemDiscount);
}
}
}
//picture
if (_shoppingCartSettings.ShowProductImagesOnWishList)
{
cartItemModel.Picture = await PrepareCartItemPicture(request, product, sci.AttributesXml);
}
//item warnings
var itemWarnings = await _shoppingCartService.GetShoppingCartItemWarnings(request.Customer, sci, product, false);
foreach (var warning in itemWarnings)
{
cartItemModel.Warnings.Add(warning);
}
model.Items.Add(cartItemModel);
}
#endregion
return(model);
}
private bool CheckCurrentSubTotalRequirement(CheckDiscountRequirementRequest request, bool includingDiscount = true)
{
var cartItems = request.Customer.GetCartItems(ShoppingCartType.ShoppingCart, request.Store.Id);
decimal spentAmount = decimal.Zero;
decimal taxRate = decimal.Zero;
foreach (var sci in cartItems)
{
spentAmount += sci.Item.Quantity * _taxService.GetProductPrice(sci.Item.Product, _priceCalculationService.GetUnitPrice(sci, includingDiscount), out taxRate);
}
return(spentAmount >= request.DiscountRequirement.SpentAmount);
}
public async Task <MiniShoppingCartModel> Handle(GetMiniShoppingCart request, CancellationToken cancellationToken)
{
var model = new MiniShoppingCartModel {
ShowProductImages = _shoppingCartSettings.ShowProductImagesInMiniShoppingCart,
DisplayShoppingCartButton = true,
CurrentCustomerIsGuest = request.Customer.IsGuest(),
AnonymousCheckoutAllowed = _orderSettings.AnonymousCheckoutAllowed,
};
if (request.Customer.ShoppingCartItems.Any())
{
var shoppingCartTypes = new List <ShoppingCartType>();
shoppingCartTypes.Add(ShoppingCartType.ShoppingCart);
shoppingCartTypes.Add(ShoppingCartType.Auctions);
if (_shoppingCartSettings.AllowOnHoldCart)
{
shoppingCartTypes.Add(ShoppingCartType.OnHoldCart);
}
var cart = _shoppingCartService.GetShoppingCart(request.Store.Id, shoppingCartTypes.ToArray());
model.TotalProducts = cart.Sum(x => x.Quantity);
if (cart.Any())
{
//subtotal
var subTotalIncludingTax = request.TaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal;
var shoppingCartSubTotal = await _orderTotalCalculationService.GetShoppingCartSubTotal(cart, subTotalIncludingTax);
decimal orderSubTotalDiscountAmountBase = shoppingCartSubTotal.discountAmount;
List <AppliedDiscount> orderSubTotalAppliedDiscounts = shoppingCartSubTotal.appliedDiscounts;
model.SubTotal = _priceFormatter.FormatPrice(shoppingCartSubTotal.subTotalWithoutDiscount, false, request.Currency, request.Language, subTotalIncludingTax);
var requiresShipping = cart.RequiresShipping();
var checkoutAttributesExist = (await _checkoutAttributeService.GetAllCheckoutAttributes(request.Store.Id, !requiresShipping)).Any();
var minOrderSubtotalAmountOk = await _mediator.Send(new ValidateMinShoppingCartSubtotalAmountCommand()
{
Customer = request.Customer,
Cart = cart.Where
(x => x.ShoppingCartType == ShoppingCartType.ShoppingCart || x.ShoppingCartType == ShoppingCartType.Auctions).ToList()
});
model.DisplayCheckoutButton = !_orderSettings.TermsOfServiceOnShoppingCartPage &&
minOrderSubtotalAmountOk &&
!checkoutAttributesExist;
//products. sort descending (recently added products)
foreach (var sci in cart
.OrderByDescending(x => x.Id)
.Take(_shoppingCartSettings.MiniShoppingCartProductNumber)
.ToList())
{
var product = await _productService.GetProductById(sci.ProductId);
if (product == null)
{
continue;
}
var cartItemModel = new MiniShoppingCartModel.ShoppingCartItemModel {
Id = sci.Id,
ProductId = product.Id,
ProductName = product.GetLocalized(x => x.Name, request.Language.Id),
ProductSeName = product.GetSeName(request.Language.Id),
Quantity = sci.Quantity,
AttributeInfo = await _productAttributeFormatter.FormatAttributes(product, sci.AttributesXml)
};
if (product.ProductType == ProductType.Reservation)
{
var reservation = "";
if (sci.RentalEndDateUtc == default(DateTime) || sci.RentalEndDateUtc == null)
{
reservation = string.Format(_localizationService.GetResource("ShoppingCart.Reservation.StartDate"), sci.RentalStartDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
else
{
reservation = string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Date"), sci.RentalStartDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat), sci.RentalEndDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
if (!string.IsNullOrEmpty(sci.Parameter))
{
reservation += "<br>" + string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Option"), sci.Parameter);
}
if (!string.IsNullOrEmpty(sci.Duration))
{
reservation += "<br>" + string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Duration"), sci.Duration);
}
if (string.IsNullOrEmpty(cartItemModel.AttributeInfo))
{
cartItemModel.AttributeInfo = reservation;
}
else
{
cartItemModel.AttributeInfo += "<br>" + reservation;
}
}
//unit prices
if (product.CallForPrice)
{
cartItemModel.UnitPrice = _localizationService.GetResource("Products.CallForPrice");
}
else
{
var productprices = await _taxService.GetProductPrice(product, (await _priceCalculationService.GetUnitPrice(sci, product)).unitprice);
decimal taxRate = productprices.taxRate;
cartItemModel.UnitPrice = _priceFormatter.FormatPrice(productprices.productprice);
}
//picture
if (_shoppingCartSettings.ShowProductImagesInMiniShoppingCart)
{
cartItemModel.Picture = await PrepareCartItemPicture(request, product, sci.AttributesXml);
}
model.Items.Add(cartItemModel);
}
}
}
return(model);
}
private async Task PrepareCartItems(ShoppingCartModel model, GetShoppingCart request)
{
#region Cart items
foreach (var sci in request.Cart)
{
var product = await _productService.GetProductById(sci.ProductId);
if (product == null)
{
continue;
}
var cartItemModel = new ShoppingCartModel.ShoppingCartItemModel {
Id = sci.Id,
Sku = product.FormatSku(sci.AttributesXml, _productAttributeParser),
IsCart = sci.ShoppingCartType == ShoppingCartType.ShoppingCart,
ProductId = product.Id,
WarehouseId = sci.WarehouseId,
ProductName = product.GetLocalized(x => x.Name, request.Language.Id),
ProductSeName = product.GetSeName(request.Language.Id),
Quantity = sci.Quantity,
AttributeInfo = await _productAttributeFormatter.FormatAttributes(product, sci.AttributesXml),
};
//allow editing?
//1. setting enabled?
//2. simple product?
//3. has attribute or gift card?
//4. visible individually?
cartItemModel.AllowItemEditing = _shoppingCartSettings.AllowCartItemEditing &&
product.ProductType == ProductType.SimpleProduct &&
(!String.IsNullOrEmpty(cartItemModel.AttributeInfo) || product.IsGiftCard) &&
product.VisibleIndividually;
//disable removal?
//1. do other items require this one?
if (product.RequireOtherProducts)
{
cartItemModel.DisableRemoval = product.RequireOtherProducts && product.ParseRequiredProductIds().Intersect(request.Cart.Select(x => x.ProductId)).Any();
}
//warehouse
if (!string.IsNullOrEmpty(cartItemModel.WarehouseId))
{
cartItemModel.WarehouseName = (await _warehouseService.GetWarehouseById(cartItemModel.WarehouseId))?.Name;
}
//vendor
if (!string.IsNullOrEmpty(product.VendorId))
{
var vendor = await _vendorService.GetVendorById(product.VendorId);
if (vendor != null)
{
cartItemModel.VendorId = product.VendorId;
cartItemModel.VendorName = vendor.Name;
cartItemModel.VendorSeName = vendor.GetSeName(request.Language.Id);
}
}
//allowed quantities
var allowedQuantities = product.ParseAllowedQuantities();
foreach (var qty in allowedQuantities)
{
cartItemModel.AllowedQuantities.Add(new SelectListItem {
Text = qty.ToString(),
Value = qty.ToString(),
Selected = sci.Quantity == qty
});
}
//recurring info
if (product.IsRecurring)
{
cartItemModel.RecurringInfo = string.Format(_localizationService.GetResource("ShoppingCart.RecurringPeriod"), product.RecurringCycleLength, product.RecurringCyclePeriod.GetLocalizedEnum(_localizationService, request.Language.Id));
}
//reservation info
if (product.ProductType == ProductType.Reservation)
{
if (sci.RentalEndDateUtc == default(DateTime) || sci.RentalEndDateUtc == null)
{
cartItemModel.ReservationInfo = string.Format(_localizationService.GetResource("ShoppingCart.Reservation.StartDate"), sci.RentalStartDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
else
{
cartItemModel.ReservationInfo = string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Date"), sci.RentalStartDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat), sci.RentalEndDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
if (!string.IsNullOrEmpty(sci.Parameter))
{
cartItemModel.ReservationInfo += "<br>" + string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Option"), sci.Parameter);
cartItemModel.Parameter = sci.Parameter;
}
if (!string.IsNullOrEmpty(sci.Duration))
{
cartItemModel.ReservationInfo += "<br>" + string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Duration"), sci.Duration);
}
}
if (sci.ShoppingCartType == ShoppingCartType.Auctions)
{
cartItemModel.DisableRemoval = true;
cartItemModel.AuctionInfo = _localizationService.GetResource("ShoppingCart.auctionwonon") + " " + _dateTimeHelper.ConvertToUserTime(product.AvailableEndDateTimeUtc.Value, DateTimeKind.Utc).ToString();
}
//unit prices
if (product.CallForPrice)
{
cartItemModel.UnitPrice = _localizationService.GetResource("Products.CallForPrice");
cartItemModel.SubTotal = _localizationService.GetResource("Products.CallForPrice");
cartItemModel.UnitPriceWithoutDiscount = _localizationService.GetResource("Products.CallForPrice");
}
else
{
var unitprices = await _priceCalculationService.GetUnitPrice(sci, product, true);
decimal discountAmount = unitprices.discountAmount;
List <AppliedDiscount> appliedDiscounts = unitprices.appliedDiscounts;
var productprices = await _taxService.GetProductPrice(product, unitprices.unitprice);
decimal taxRate = productprices.taxRate;
cartItemModel.UnitPriceWithoutDiscountValue =
(await _taxService.GetProductPrice(product, (await _priceCalculationService.GetUnitPrice(sci, product, false)).unitprice)).productprice;
cartItemModel.UnitPriceWithoutDiscount = _priceFormatter.FormatPrice(cartItemModel.UnitPriceWithoutDiscountValue);
cartItemModel.UnitPriceValue = productprices.productprice;
cartItemModel.UnitPrice = _priceFormatter.FormatPrice(productprices.productprice);
if (appliedDiscounts != null && appliedDiscounts.Any())
{
var discount = await _discountService.GetDiscountById(appliedDiscounts.FirstOrDefault().DiscountId);
if (discount != null && discount.MaximumDiscountedQuantity.HasValue)
{
cartItemModel.DiscountedQty = discount.MaximumDiscountedQuantity.Value;
}
foreach (var disc in appliedDiscounts)
{
cartItemModel.Discounts.Add(disc.DiscountId);
}
}
//sub total
var subtotal = await _priceCalculationService.GetSubTotal(sci, product, true);
decimal shoppingCartItemDiscountBase = subtotal.discountAmount;
List <AppliedDiscount> scDiscounts = subtotal.appliedDiscounts;
var shoppingCartItemSubTotalWithDiscount = (await _taxService.GetProductPrice(product, subtotal.subTotal)).productprice;
cartItemModel.SubTotal = _priceFormatter.FormatPrice(shoppingCartItemSubTotalWithDiscount);
cartItemModel.SubTotalValue = shoppingCartItemSubTotalWithDiscount;
//display an applied discount amount
if (shoppingCartItemDiscountBase > decimal.Zero)
{
shoppingCartItemDiscountBase = (await _taxService.GetProductPrice(product, shoppingCartItemDiscountBase)).productprice;
if (shoppingCartItemDiscountBase > decimal.Zero)
{
cartItemModel.Discount = _priceFormatter.FormatPrice(shoppingCartItemDiscountBase);
}
}
}
//picture
if (_shoppingCartSettings.ShowProductImagesOnShoppingCart)
{
cartItemModel.Picture = await PrepareCartItemPicture(product, sci.AttributesXml, request.Language.Id, request.Store.Id);
}
//item warnings
var itemWarnings = await _shoppingCartService.GetShoppingCartItemWarnings(request.Customer, sci, product, false);
foreach (var warning in itemWarnings)
{
cartItemModel.Warnings.Add(warning);
}
model.Items.Add(cartItemModel);
}
#endregion
}
public async Task <ProductDetailsAttributeChangeModel> Handle(GetProductDetailsAttributeChange request, CancellationToken cancellationToken)
{
var model = new ProductDetailsAttributeChangeModel();
string attributeXml = await _mediator.Send(new GetParseProductAttributes()
{
Product = request.Product, Form = request.Form
});
string warehouseId = _shoppingCartSettings.AllowToSelectWarehouse ?
request.Form["WarehouseId"].ToString() :
request.Product.UseMultipleWarehouses ? request.Store.DefaultWarehouseId :
(string.IsNullOrEmpty(request.Store.DefaultWarehouseId) ? request.Product.WarehouseId : request.Store.DefaultWarehouseId);
//rental attributes
DateTime?rentalStartDate = null;
DateTime?rentalEndDate = null;
if (request.Product.ProductType == ProductType.Reservation)
{
request.Product.ParseReservationDates(request.Form, out rentalStartDate, out rentalEndDate);
}
model.Sku = request.Product.FormatSku(attributeXml, _productAttributeParser);
model.Mpn = request.Product.FormatMpn(attributeXml, _productAttributeParser);
model.Gtin = request.Product.FormatGtin(attributeXml, _productAttributeParser);
if (await _permissionService.Authorize(StandardPermissionProvider.DisplayPrices) && !request.Product.CustomerEntersPrice && request.Product.ProductType != ProductType.Auction)
{
//we do not calculate price of "customer enters price" option is enabled
var unitprice = await _priceCalculationService.GetUnitPrice(request.Product,
request.Customer,
ShoppingCartType.ShoppingCart,
1, attributeXml, 0,
rentalStartDate, rentalEndDate,
true);
decimal discountAmount = unitprice.discountAmount;
List <AppliedDiscount> scDiscounts = unitprice.appliedDiscounts;
decimal finalPrice = unitprice.unitprice;
var productprice = await _taxService.GetProductPrice(request.Product, finalPrice);
decimal finalPriceWithDiscountBase = productprice.productprice;
decimal taxRate = productprice.taxRate;
decimal finalPriceWithDiscount = await _currencyService.ConvertFromPrimaryStoreCurrency(finalPriceWithDiscountBase, request.Currency);
model.Price = _priceFormatter.FormatPrice(finalPriceWithDiscount);
}
//stock
model.StockAvailability = request.Product.FormatStockMessage(warehouseId, attributeXml, _localizationService, _productAttributeParser);
//back in stock subscription
if ((request.Product.ManageInventoryMethod == ManageInventoryMethod.ManageStockByAttributes ||
request.Product.ManageInventoryMethod == ManageInventoryMethod.ManageStock) &&
request.Product.BackorderMode == BackorderMode.NoBackorders &&
request.Product.AllowBackInStockSubscriptions)
{
var combination = _productAttributeParser.FindProductAttributeCombination(request.Product, attributeXml);
if (combination != null)
{
if (request.Product.GetTotalStockQuantityForCombination(combination, warehouseId: request.Store.DefaultWarehouseId) <= 0)
{
model.DisplayBackInStockSubscription = true;
}
}
if (request.Product.ManageInventoryMethod == ManageInventoryMethod.ManageStock)
{
model.DisplayBackInStockSubscription = request.Product.AllowBackInStockSubscriptions;
attributeXml = "";
}
var subscription = await _backInStockSubscriptionService
.FindSubscription(request.Customer.Id,
request.Product.Id, attributeXml, request.Store.Id, warehouseId);
if (subscription != null)
{
model.ButtonTextBackInStockSubscription = _localizationService.GetResource("BackInStockSubscriptions.DeleteNotifyWhenAvailable");
}
else
{
model.ButtonTextBackInStockSubscription = _localizationService.GetResource("BackInStockSubscriptions.NotifyMeWhenAvailable");
}
}
//conditional attributes
if (request.ValidateAttributeConditions)
{
var attributes = request.Product.ProductAttributeMappings;
foreach (var attribute in attributes)
{
var conditionMet = _productAttributeParser.IsConditionMet(request.Product, attribute, attributeXml);
if (conditionMet.HasValue)
{
if (conditionMet.Value)
{
model.EnabledAttributeMappingIds.Add(attribute.Id);
}
else
{
model.DisabledAttributeMappingids.Add(attribute.Id);
}
}
}
}
//picture. used when we want to override a default product picture when some attribute is selected
if (request.LoadPicture)
{
//first, try to get product attribute combination picture
var pictureId = request.Product.ProductAttributeCombinations.Where(x => x.AttributesXml == attributeXml).FirstOrDefault()?.PictureId ?? "";
//then, let's see whether we have attribute values with pictures
if (string.IsNullOrEmpty(pictureId))
{
pictureId = _productAttributeParser.ParseProductAttributeValues(request.Product, attributeXml)
.FirstOrDefault(attributeValue => !string.IsNullOrEmpty(attributeValue.PictureId))?.PictureId ?? "";
}
if (!string.IsNullOrEmpty(pictureId))
{
var pictureModel = new PictureModel {
Id = pictureId,
FullSizeImageUrl = await _pictureService.GetPictureUrl(pictureId),
ImageUrl = await _pictureService.GetPictureUrl(pictureId, _mediaSettings.ProductDetailsPictureSize)
};
model.PictureFullSizeUrl = pictureModel.FullSizeImageUrl;
model.PictureDefaultSizeUrl = pictureModel.ImageUrl;
}
}
return(model);
}
public SetExpressCheckoutResponseType SetExpressCheckout(PayPalProcessPaymentRequest processPaymentRequest,
IList <Core.Domain.Orders.OrganizedShoppingCartItem> cart)
{
var result = new SetExpressCheckoutResponseType();
var currentStore = CommonServices.StoreContext.CurrentStore;
var req = new SetExpressCheckoutReq
{
SetExpressCheckoutRequest = new SetExpressCheckoutRequestType
{
Version = PayPalHelper.GetApiVersion(),
SetExpressCheckoutRequestDetails = new SetExpressCheckoutRequestDetailsType()
}
};
var details = new SetExpressCheckoutRequestDetailsType
{
PaymentAction = PayPalHelper.GetPaymentAction(Settings),
PaymentActionSpecified = true,
CancelURL = CommonServices.WebHelper.GetStoreLocation(currentStore.SslEnabled) + "cart",
ReturnURL = CommonServices.WebHelper.GetStoreLocation(currentStore.SslEnabled) + "Plugins/SmartStore.PayPal/PayPalExpress/GetDetails",
//CallbackURL = _webHelper.GetStoreLocation(currentStore.SslEnabled) + "Plugins/SmartStore.PayPal/PayPalExpress/ShippingOptions?CustomerID=" + _workContext.CurrentCustomer.Id.ToString(),
//CallbackTimeout = _payPalExpressPaymentSettings.CallbackTimeout.ToString()
ReqConfirmShipping = Settings.ConfirmedShipment.ToString(),
NoShipping = Settings.NoShipmentAddress.ToString()
};
// populate cart
decimal itemTotal = decimal.Zero;
var cartItems = new List <PaymentDetailsItemType>();
foreach (OrganizedShoppingCartItem item in cart)
{
decimal shoppingCartUnitPriceWithDiscountBase = _priceCalculationService.GetUnitPrice(item, true);
decimal shoppingCartUnitPriceWithDiscount = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartUnitPriceWithDiscountBase, CommonServices.WorkContext.WorkingCurrency);
decimal priceIncludingTier = shoppingCartUnitPriceWithDiscount;
cartItems.Add(new PaymentDetailsItemType()
{
Name = item.Item.Product.Name,
Number = item.Item.Product.Sku,
Quantity = item.Item.Quantity.ToString(),
Amount = new BasicAmountType() // this is the per item cost
{
currencyID = PayPalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId)),
Value = (priceIncludingTier).ToString("N", new CultureInfo("en-us"))
}
});
itemTotal += (item.Item.Quantity * priceIncludingTier);
}
;
decimal shippingTotal = decimal.Zero;
if (cart.RequiresShipping())
{
decimal?shoppingCartShippingBase = OrderTotalCalculationService.GetShoppingCartShippingTotal(cart);
if (shoppingCartShippingBase.HasValue && shoppingCartShippingBase > 0)
{
shippingTotal = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartShippingBase.Value, CommonServices.WorkContext.WorkingCurrency);
}
else
{
shippingTotal = Settings.DefaultShippingPrice;
}
}
//This is the default if the Shipping Callback fails
//var shippingOptions = new List<ShippingOptionType>();
//shippingOptions.Add(new ShippingOptionType()
//{
// ShippingOptionIsDefault = "true",
// ShippingOptionName = "Standard Shipping",
// ShippingOptionAmount = new BasicAmountType()
// {
// Value = shippingTotal.ToString(), //This is the default value used for shipping if the Instant Update API returns an error or does not answer within the callback time
// currencyID = PaypalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId))
// }
//});
//details.FlatRateShippingOptions = shippingOptions.ToArray();
//details.TotalType = TotalType.EstimatedTotal;
// get total tax
SortedDictionary <decimal, decimal> taxRates = null;
decimal shoppingCartTaxBase = OrderTotalCalculationService.GetTaxTotal(cart, out taxRates);
decimal shoppingCartTax = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartTaxBase, CommonServices.WorkContext.WorkingCurrency);
decimal discount = -processPaymentRequest.Discount;
// Add discounts to PayPal order
if (discount != 0)
{
cartItems.Add(new PaymentDetailsItemType()
{
Name = "Threadrock Discount",
Quantity = "1",
Amount = new BasicAmountType() // this is the total discount
{
currencyID = PayPalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId)),
Value = discount.ToString("N", new CultureInfo("en-us"))
}
});
itemTotal += discount;
}
// get customer
int customerId = Convert.ToInt32(CommonServices.WorkContext.CurrentCustomer.Id.ToString());
var customer = _customerService.GetCustomerById(customerId);
if (!cart.IsRecurring())
{
//we don't apply gift cards for recurring products
var giftCards = _giftCardService.GetActiveGiftCardsAppliedByCustomer(customer);
if (giftCards != null)
{
foreach (var gc in giftCards)
{
if (itemTotal > decimal.Zero)
{
decimal remainingAmount = gc.GetGiftCardRemainingAmount();
decimal amountCanBeUsed = decimal.Zero;
if (itemTotal > remainingAmount)
{
amountCanBeUsed = remainingAmount;
}
else
{
amountCanBeUsed = itemTotal - .01M;
}
decimal amountToSubtract = -amountCanBeUsed;
cartItems.Add(new PaymentDetailsItemType()
{
Name = "Giftcard Applied",
Quantity = "1",
Amount = new BasicAmountType()
{
currencyID = PayPalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId)),
Value = amountToSubtract.ToString("N", new CultureInfo("en-us"))
}
});
//reduce subtotal
itemTotal += amountToSubtract;
}
}
}
}
// populate payment details
var paymentDetails = new PaymentDetailsType
{
ItemTotal = new BasicAmountType
{
Value = Math.Round(itemTotal, 2).ToString("N", new CultureInfo("en-us")),
currencyID = PayPalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId))
},
ShippingTotal = new BasicAmountType
{
Value = Math.Round(shippingTotal, 2).ToString("N", new CultureInfo("en-us")),
currencyID = PayPalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId))
},
TaxTotal = new BasicAmountType
{
Value = Math.Round(shoppingCartTax, 2).ToString("N", new CultureInfo("en-us")),
currencyID = PayPalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId))
},
OrderTotal = new BasicAmountType
{
Value = Math.Round(itemTotal + shoppingCartTax + shippingTotal, 2).ToString("N", new CultureInfo("en-us")),
currencyID = PayPalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId))
},
Custom = processPaymentRequest.OrderGuid.ToString(),
ButtonSource = SmartStoreVersion.CurrentFullVersion,
PaymentAction = PayPalHelper.GetPaymentAction(Settings),
PaymentDetailsItem = cartItems.ToArray()
};
details.PaymentDetails = new[] { paymentDetails };
//details.MaxAmount = new BasicAmountType() // this is the per item cost
//{
// currencyID = PaypalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId)),
// Value = (decimal.Parse(paymentDetails.OrderTotal.Value) + 30).ToString()
//};
details.ShippingMethodSpecified = true;
req.SetExpressCheckoutRequest.SetExpressCheckoutRequestDetails.Custom = processPaymentRequest.OrderGuid.ToString();
req.SetExpressCheckoutRequest.SetExpressCheckoutRequestDetails = details;
using (var service = new PayPalAPIAASoapBinding())
{
service.Url = PayPalHelper.GetPaypalServiceUrl(Settings);
service.RequesterCredentials = PayPalHelper.GetPaypalApiCredentials(Settings);
result = service.SetExpressCheckout(req);
}
_httpContext.GetCheckoutState().CustomProperties.Add("PayPalExpressButtonUsed", true);
return(result);
}
public ActionResult GetCartDetails(int customerId)
{
var gridModel = new GridModel <ShoppingCartItemModel>();
if (_permissionService.Authorize(StandardPermissionProvider.ManageOrders))
{
var customer = _customerService.GetCustomerById(customerId);
var cart = customer.GetCartItems(ShoppingCartType.ShoppingCart);
gridModel.Data = cart.Select(sci =>
{
decimal taxRate;
var store = _storeService.GetStoreById(sci.Item.StoreId);
var sciModel = new ShoppingCartItemModel
{
Id = sci.Item.Id,
Store = store != null ? store.Name : "".NaIfEmpty(),
ProductId = sci.Item.ProductId,
Quantity = sci.Item.Quantity,
ProductName = sci.Item.Product.Name,
ProductTypeName = sci.Item.Product.GetProductTypeLabel(_localizationService),
ProductTypeLabelHint = sci.Item.Product.ProductTypeLabelHint,
UnitPrice = _priceFormatter.FormatPrice(_taxService.GetProductPrice(sci.Item.Product, _priceCalculationService.GetUnitPrice(sci, true), out taxRate)),
Total = _priceFormatter.FormatPrice(_taxService.GetProductPrice(sci.Item.Product, _priceCalculationService.GetSubTotal(sci, true), out taxRate)),
UpdatedOn = _dateTimeHelper.ConvertToUserTime(sci.Item.UpdatedOnUtc, DateTimeKind.Utc)
};
return(sciModel);
});
gridModel.Total = cart.Count;
}
else
{
gridModel.Data = Enumerable.Empty <ShoppingCartItemModel>();
NotifyAccessDenied();
}
return(new JsonResult
{
Data = gridModel
});
}
public async Task <AddToCartModel> Handle(GetAddToCart request, CancellationToken cancellationToken)
{
var model = new AddToCartModel();
model.AttributeDescription = await _productAttributeFormatter.FormatAttributes(request.Product, request.AttributesXml);
model.ProductSeName = request.Product.GetSeName(request.Language.Id);
model.CartType = request.CartType;
model.ProductId = request.Product.Id;
model.ProductName = request.Product.GetLocalized(x => x.Name, request.Language.Id);
model.Quantity = request.Quantity;
//reservation info
if (request.Product.ProductType == ProductType.Reservation)
{
if (request.EndDate == default(DateTime) || request.EndDate == null)
{
model.ReservationInfo = string.Format(_localizationService.GetResource("ShoppingCart.Reservation.StartDate"), request.StartDate?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
else
{
model.ReservationInfo = string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Date"), request.StartDate?.ToString(_shoppingCartSettings.ReservationDateFormat), request.EndDate?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
if (!string.IsNullOrEmpty(request.Parameter))
{
model.ReservationInfo += "<br>" + string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Option"), request.Parameter);
}
if (!string.IsNullOrEmpty(request.Duration))
{
model.ReservationInfo += "<br>" + string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Duration"), request.Duration);
}
}
if (request.CartType != ShoppingCartType.Auctions)
{
var sci = request.Customer.ShoppingCartItems.FirstOrDefault(x => x.ProductId == request.Product.Id &&
(string.IsNullOrEmpty(x.AttributesXml) ? "" : x.AttributesXml) == request.AttributesXml);
model.ItemQuantity = sci.Quantity;
//unit prices
if (request.Product.CallForPrice)
{
model.Price = _localizationService.GetResource("Products.CallForPrice");
}
else
{
var productprices = await _taxService.GetProductPrice(request.Product, (await _priceCalculationService.GetUnitPrice(sci)).unitprice);
decimal taxRate = productprices.taxRate;
decimal shoppingCartUnitPriceWithDiscountBase = productprices.productprice;
decimal shoppingCartUnitPriceWithDiscount = await _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartUnitPriceWithDiscountBase, request.Currency);
model.Price = request.CustomerEnteredPrice == 0 ? _priceFormatter.FormatPrice(shoppingCartUnitPriceWithDiscount) : _priceFormatter.FormatPrice(request.CustomerEnteredPrice);
model.DecimalPrice = request.CustomerEnteredPrice == 0 ? shoppingCartUnitPriceWithDiscount : request.CustomerEnteredPrice;
model.TotalPrice = _priceFormatter.FormatPrice(shoppingCartUnitPriceWithDiscount * sci.Quantity);
}
//picture
model.Picture = await PrepareCartItemPicture(request);
}
else
{
model.Picture = await PrepareCartItemPicture(request);
}
var cart = _shoppingCartService.GetShoppingCart(request.Store.Id, request.CartType);
if (request.CartType != ShoppingCartType.Auctions)
{
model.TotalItems = cart.Sum(x => x.Quantity);
}
else
{
model.TotalItems = 0;
var grouped = (await _auctionService.GetBidsByCustomerId(request.Customer.Id)).GroupBy(x => x.ProductId);
foreach (var item in grouped)
{
var p = await _productService.GetProductById(item.Key);
if (p != null && p.AvailableEndDateTimeUtc > DateTime.UtcNow)
{
model.TotalItems++;
}
}
}
if (request.CartType == ShoppingCartType.ShoppingCart)
{
var subTotalIncludingTax = request.TaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal;
var shoppingCartSubTotal = await _orderTotalCalculationService.GetShoppingCartSubTotal(cart, subTotalIncludingTax);
decimal orderSubTotalDiscountAmountBase = shoppingCartSubTotal.discountAmount;
List <AppliedDiscount> orderSubTotalAppliedDiscounts = shoppingCartSubTotal.appliedDiscounts;
decimal subTotalWithoutDiscountBase = shoppingCartSubTotal.subTotalWithoutDiscount;
decimal subTotalWithDiscountBase = shoppingCartSubTotal.subTotalWithDiscount;
decimal subtotalBase = subTotalWithoutDiscountBase;
decimal subtotal = await _currencyService.ConvertFromPrimaryStoreCurrency(subtotalBase, request.Currency);
model.SubTotal = _priceFormatter.FormatPrice(subtotal, true, request.Currency, request.Language, subTotalIncludingTax);
model.DecimalSubTotal = subtotal;
if (orderSubTotalDiscountAmountBase > decimal.Zero)
{
decimal orderSubTotalDiscountAmount = await _currencyService.ConvertFromPrimaryStoreCurrency(orderSubTotalDiscountAmountBase, request.Currency);
model.SubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountAmount, true, request.Currency, request.Language, subTotalIncludingTax);
}
}
else if (request.CartType == ShoppingCartType.Auctions)
{
model.IsAuction = true;
model.HighestBidValue = request.Product.HighestBid;
model.HighestBid = _priceFormatter.FormatPrice(request.Product.HighestBid);
model.EndTime = request.Product.AvailableEndDateTimeUtc;
}
return(model);
}
public HttpResponseMessage GetCartDetails(HttpRequestMessage request, int customerId)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = request.CreateErrorResponse(HttpStatusCode.NotFound, "No items found");
if (true)
{
var customer = _customerService.GetCustomerById(customerId);
var cart = customer.ShoppingCartItems.Where(x => x.ShoppingCartType == ShoppingCartType.ShoppingCart).ToList();
var gridModel = new DataSourceResult
{
Data = cart.Select(sci =>
{
decimal taxRate;
var store = _storeService.GetStoreById(sci.StoreId);
var sciModel = new ShoppingCartItemVM
{
Id = sci.Id,
Store = store != null ? store.Name : "Unknown",
ProductId = sci.ProductId,
Quantity = sci.Quantity,
ProductName = sci.Product.Name,
AttributeInfo = _productAttributeFormatter.FormatAttributes(sci.Product, sci.AttributesXml, sci.Customer),
UnitPrice = _priceFormatter.FormatPrice(_taxService.GetProductPrice(sci.Product, _priceCalculationService.GetUnitPrice(sci), out taxRate)),
Total = _priceFormatter.FormatPrice(_taxService.GetProductPrice(sci.Product, _priceCalculationService.GetSubTotal(sci), out taxRate)),
UpdatedOn = _dateTimeHelper.ConvertToUserTime(sci.UpdatedOnUtc, DateTimeKind.Utc)
};
return sciModel;
}),
Total = cart.Count
};
response = request.CreateResponse <DataSourceResult>(HttpStatusCode.OK, gridModel);
}
else
{
response = request.CreateResponse(HttpStatusCode.Unauthorized, "Unauthorized user");
}
return response;
}));
}
private List <ShoppingCartItemModel> GetCartItemModels(ShoppingCartType cartType, Customer customer)
{
decimal taxRate;
var cart = customer.GetCartItems(cartType);
var stores = Services.StoreService.GetAllStores().ToDictionary(x => x.Id, x => x);
var result = cart.Select(sci =>
{
stores.TryGetValue(sci.Item.StoreId, out var store);
var model = new ShoppingCartItemModel
{
Id = sci.Item.Id,
Store = store?.Name?.NaIfEmpty(),
ProductId = sci.Item.ProductId,
Quantity = sci.Item.Quantity,
ProductName = sci.Item.Product.GetLocalized(x => x.Name),
ProductTypeName = sci.Item.Product.GetProductTypeLabel(Services.Localization),
ProductTypeLabelHint = sci.Item.Product.ProductTypeLabelHint,
UnitPrice = _priceFormatter.FormatPrice(_taxService.GetProductPrice(sci.Item.Product, _priceCalculationService.GetUnitPrice(sci, true), out taxRate)),
Total = _priceFormatter.FormatPrice(_taxService.GetProductPrice(sci.Item.Product, _priceCalculationService.GetSubTotal(sci, true), out taxRate)),
UpdatedOn = _dateTimeHelper.ConvertToUserTime(sci.Item.UpdatedOnUtc, DateTimeKind.Utc)
};
return(model);
});
return(result.ToList());
}
public virtual void PrepareShoppingCartModel(ShoppingCartModel model,
IList <ShoppingCartItem> cart, bool isEditable = true,
bool validateCheckoutAttributes = false,
bool prepareEstimateShippingIfEnabled = true, bool setEstimateShippingDefaultAddress = true,
bool prepareAndDisplayOrderReviewData = false)
{
if (cart == null)
{
throw new ArgumentNullException("cart");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OnePageCheckoutEnabled = _orderSettings.OnePageCheckoutEnabled;
if (cart.Count == 0)
{
return;
}
#region Simple properties
model.IsEditable = isEditable;
model.ShowProductImages = _shoppingCartSettings.ShowProductImagesOnShoppingCart;
model.ShowSku = _catalogSettings.ShowProductSku;
var checkoutAttributesXml = _workContext.CurrentCustomer.GetAttribute <string>(SystemCustomerAttributeNames.CheckoutAttributes, _genericAttributeService, _storeContext.CurrentStore.Id);
model.CheckoutAttributeInfo = _checkoutAttributeFormatter.FormatAttributes(checkoutAttributesXml, _workContext.CurrentCustomer);
bool minOrderSubtotalAmountOk = _orderProcessingService.ValidateMinOrderSubtotalAmount(cart);
if (!minOrderSubtotalAmountOk)
{
decimal minOrderSubtotalAmount = _currencyService.ConvertFromPrimaryStoreCurrency(_orderSettings.MinOrderSubtotalAmount, _workContext.WorkingCurrency);
model.MinOrderSubtotalWarning = string.Format(_localizationService.GetResource("Checkout.MinOrderSubtotalAmount"), _priceFormatter.FormatPrice(minOrderSubtotalAmount, true, false));
}
model.TermsOfServiceOnShoppingCartPage = _orderSettings.TermsOfServiceOnShoppingCartPage;
model.TermsOfServiceOnOrderConfirmPage = _orderSettings.TermsOfServiceOnOrderConfirmPage;
//gift card and gift card boxes
model.DiscountBox.Display = _shoppingCartSettings.ShowDiscountBox;
var discountCouponCode = _workContext.CurrentCustomer.GetAttribute <string>(SystemCustomerAttributeNames.DiscountCouponCode);
var discount = _discountService.GetDiscountByCouponCode(discountCouponCode);
if (discount != null &&
discount.RequiresCouponCode &&
_discountService.IsDiscountValid(discount, _workContext.CurrentCustomer))
{
model.DiscountBox.CurrentCode = discount.CouponCode;
}
model.GiftCardBox.Display = _shoppingCartSettings.ShowGiftCardBox;
//cart warnings
var cartWarnings = _shoppingCartService.GetShoppingCartWarnings(cart, checkoutAttributesXml, validateCheckoutAttributes);
foreach (var warning in cartWarnings)
{
model.Warnings.Add(warning);
}
#endregion
#region Checkout attributes
var checkoutAttributes = _checkoutAttributeService.GetAllCheckoutAttributes(_storeContext.CurrentStore.Id, !cart.RequiresShipping());
foreach (var attribute in checkoutAttributes)
{
var attributeModel = new ShoppingCartModel.CheckoutAttributeModel
{
Id = attribute.Id,
Name = attribute.GetLocalized(x => x.Name),
TextPrompt = attribute.GetLocalized(x => x.TextPrompt),
IsRequired = attribute.IsRequired,
AttributeControlType = attribute.AttributeControlType,
DefaultValue = attribute.DefaultValue
};
if (!String.IsNullOrEmpty(attribute.ValidationFileAllowedExtensions))
{
attributeModel.AllowedFileExtensions = attribute.ValidationFileAllowedExtensions
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.ToList();
}
if (attribute.ShouldHaveValues())
{
//values
var attributeValues = _checkoutAttributeService.GetCheckoutAttributeValues(attribute.Id);
foreach (var attributeValue in attributeValues)
{
var attributeValueModel = new ShoppingCartModel.CheckoutAttributeValueModel
{
Id = attributeValue.Id,
Name = attributeValue.GetLocalized(x => x.Name),
ColorSquaresRgb = attributeValue.ColorSquaresRgb,
IsPreSelected = attributeValue.IsPreSelected,
};
attributeModel.Values.Add(attributeValueModel);
//display price if allowed
if (_permissionService.Authorize(StandardPermissionProvider.DisplayPrices))
{
decimal priceAdjustmentBase = _taxService.GetCheckoutAttributePrice(attributeValue);
decimal priceAdjustment = _currencyService.ConvertFromPrimaryStoreCurrency(priceAdjustmentBase, _workContext.WorkingCurrency);
if (priceAdjustmentBase > decimal.Zero)
{
attributeValueModel.PriceAdjustment = "+" + _priceFormatter.FormatPrice(priceAdjustment);
}
else if (priceAdjustmentBase < decimal.Zero)
{
attributeValueModel.PriceAdjustment = "-" + _priceFormatter.FormatPrice(-priceAdjustment);
}
}
}
}
//set already selected attributes
var selectedCheckoutAttributes = _workContext.CurrentCustomer.GetAttribute <string>(SystemCustomerAttributeNames.CheckoutAttributes, _genericAttributeService, _storeContext.CurrentStore.Id);
switch (attribute.AttributeControlType)
{
case AttributeControlType.DropdownList:
case AttributeControlType.RadioList:
case AttributeControlType.Checkboxes:
case AttributeControlType.ColorSquares:
{
if (!String.IsNullOrEmpty(selectedCheckoutAttributes))
{
//clear default selection
foreach (var item in attributeModel.Values)
{
item.IsPreSelected = false;
}
//select new values
var selectedValues = _checkoutAttributeParser.ParseCheckoutAttributeValues(selectedCheckoutAttributes);
foreach (var attributeValue in selectedValues)
{
foreach (var item in attributeModel.Values)
{
if (attributeValue.Id == item.Id)
{
item.IsPreSelected = true;
}
}
}
}
}
break;
case AttributeControlType.ReadonlyCheckboxes:
{
//do nothing
//values are already pre-set
}
break;
case AttributeControlType.TextBox:
case AttributeControlType.MultilineTextbox:
{
if (!String.IsNullOrEmpty(selectedCheckoutAttributes))
{
var enteredText = _checkoutAttributeParser.ParseValues(selectedCheckoutAttributes, attribute.Id);
if (enteredText.Count > 0)
{
attributeModel.DefaultValue = enteredText[0];
}
}
}
break;
case AttributeControlType.Datepicker:
{
//keep in mind my that the code below works only in the current culture
var selectedDateStr = _checkoutAttributeParser.ParseValues(selectedCheckoutAttributes, attribute.Id);
if (selectedDateStr.Count > 0)
{
DateTime selectedDate;
if (DateTime.TryParseExact(selectedDateStr[0], "D", CultureInfo.CurrentCulture,
DateTimeStyles.None, out selectedDate))
{
//successfully parsed
attributeModel.SelectedDay = selectedDate.Day;
attributeModel.SelectedMonth = selectedDate.Month;
attributeModel.SelectedYear = selectedDate.Year;
}
}
}
break;
default:
break;
}
model.CheckoutAttributes.Add(attributeModel);
}
#endregion
#region Estimate shipping
if (prepareEstimateShippingIfEnabled)
{
model.EstimateShipping.Enabled = cart.Count > 0 && cart.RequiresShipping() && _shippingSettings.EstimateShippingEnabled;
if (model.EstimateShipping.Enabled)
{
//countries
int?defaultEstimateCountryId = (setEstimateShippingDefaultAddress && _workContext.CurrentCustomer.ShippingAddress != null) ? _workContext.CurrentCustomer.ShippingAddress.CountryId : model.EstimateShipping.CountryId;
model.EstimateShipping.AvailableCountries.Add(new SelectListItem {
Text = _localizationService.GetResource("Address.SelectCountry"), Value = "0"
});
foreach (var c in _countryService.GetAllCountriesForShipping())
{
model.EstimateShipping.AvailableCountries.Add(new SelectListItem
{
Text = c.GetLocalized(x => x.Name),
Value = c.Id.ToString(),
Selected = c.Id == defaultEstimateCountryId
});
}
//states
int?defaultEstimateStateId = (setEstimateShippingDefaultAddress && _workContext.CurrentCustomer.ShippingAddress != null) ? _workContext.CurrentCustomer.ShippingAddress.StateProvinceId : model.EstimateShipping.StateProvinceId;
var states = defaultEstimateCountryId.HasValue ? _stateProvinceService.GetStateProvincesByCountryId(defaultEstimateCountryId.Value).ToList() : new List <StateProvince>();
if (states.Count > 0)
{
foreach (var s in states)
{
model.EstimateShipping.AvailableStates.Add(new SelectListItem
{
Text = s.GetLocalized(x => x.Name),
Value = s.Id.ToString(),
Selected = s.Id == defaultEstimateStateId
});
}
}
else
{
model.EstimateShipping.AvailableStates.Add(new SelectListItem {
Text = _localizationService.GetResource("Address.OtherNonUS"), Value = "0"
});
}
if (setEstimateShippingDefaultAddress && _workContext.CurrentCustomer.ShippingAddress != null)
{
model.EstimateShipping.ZipPostalCode = _workContext.CurrentCustomer.ShippingAddress.ZipPostalCode;
}
}
}
#endregion
#region Cart items
foreach (var sci in cart)
{
var cartItemModel = new ShoppingCartModel.ShoppingCartItemModel
{
Id = sci.Id,
Sku = sci.Product.FormatSku(sci.AttributesXml, _productAttributeParser),
ProductId = sci.Product.Id,
ProductName = sci.Product.GetLocalized(x => x.Name),
ProductSeName = sci.Product.GetSeName(),
Quantity = sci.Quantity,
AttributeInfo = _productAttributeFormatter.FormatAttributes(sci.Product, sci.AttributesXml),
};
//allow editing?
//1. setting enabled?
//2. simple product?
//3. has attribute or gift card?
//4. visible individually?
cartItemModel.AllowItemEditing = _shoppingCartSettings.AllowCartItemEditing &&
sci.Product.ProductType == ProductType.SimpleProduct &&
(!String.IsNullOrEmpty(cartItemModel.AttributeInfo) || sci.Product.IsGiftCard) &&
sci.Product.VisibleIndividually;
//allowed quantities
var allowedQuantities = sci.Product.ParseAllowedQuatities();
foreach (var qty in allowedQuantities)
{
cartItemModel.AllowedQuantities.Add(new SelectListItem
{
Text = qty.ToString(),
Value = qty.ToString(),
Selected = sci.Quantity == qty
});
}
//recurring info
if (sci.Product.IsRecurring)
{
cartItemModel.RecurringInfo = string.Format(_localizationService.GetResource("ShoppingCart.RecurringPeriod"), sci.Product.RecurringCycleLength, sci.Product.RecurringCyclePeriod.GetLocalizedEnum(_localizationService, _workContext));
}
//rental info
if (sci.Product.IsRental)
{
var rentalStartDate = sci.RentalStartDateUtc.HasValue ? sci.Product.FormatRentalDate(sci.RentalStartDateUtc.Value) : "";
var rentalEndDate = sci.RentalEndDateUtc.HasValue ? sci.Product.FormatRentalDate(sci.RentalEndDateUtc.Value) : "";
cartItemModel.RentalInfo = string.Format(_localizationService.GetResource("ShoppingCart.Rental.FormattedDate"),
rentalStartDate, rentalEndDate);
}
//unit prices
if (sci.Product.CallForPrice)
{
cartItemModel.UnitPrice = _localizationService.GetResource("Products.CallForPrice");
}
else
{
decimal taxRate;
decimal shoppingCartUnitPriceWithDiscountBase = _taxService.GetProductPrice(sci.Product, _priceCalculationService.GetUnitPrice(sci), out taxRate);
decimal shoppingCartUnitPriceWithDiscount = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartUnitPriceWithDiscountBase, _workContext.WorkingCurrency);
cartItemModel.UnitPrice = _priceFormatter.FormatPrice(shoppingCartUnitPriceWithDiscount);
}
//subtotal, discount
if (sci.Product.CallForPrice)
{
cartItemModel.SubTotal = _localizationService.GetResource("Products.CallForPrice");
}
else
{
//sub total
Discount scDiscount;
decimal shoppingCartItemDiscountBase;
decimal taxRate;
decimal shoppingCartItemSubTotalWithDiscountBase = _taxService.GetProductPrice(sci.Product, _priceCalculationService.GetSubTotal(sci, true, out shoppingCartItemDiscountBase, out scDiscount), out taxRate);
decimal shoppingCartItemSubTotalWithDiscount = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartItemSubTotalWithDiscountBase, _workContext.WorkingCurrency);
cartItemModel.SubTotal = _priceFormatter.FormatPrice(shoppingCartItemSubTotalWithDiscount);
//display an applied discount amount
if (scDiscount != null)
{
shoppingCartItemDiscountBase = _taxService.GetProductPrice(sci.Product, shoppingCartItemDiscountBase, out taxRate);
if (shoppingCartItemDiscountBase > decimal.Zero)
{
decimal shoppingCartItemDiscount = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartItemDiscountBase, _workContext.WorkingCurrency);
cartItemModel.Discount = _priceFormatter.FormatPrice(shoppingCartItemDiscount);
}
}
}
//item warnings
var itemWarnings = _shoppingCartService.GetShoppingCartItemWarnings(
_workContext.CurrentCustomer,
sci.ShoppingCartType,
sci.Product,
sci.StoreId,
sci.AttributesXml,
sci.CustomerEnteredPrice,
sci.RentalStartDateUtc,
sci.RentalEndDateUtc,
sci.Quantity,
false);
foreach (var warning in itemWarnings)
{
cartItemModel.Warnings.Add(warning);
}
model.Items.Add(cartItemModel);
}
#endregion
#region Button payment methods
var paymentMethods = _paymentService
.LoadActivePaymentMethods(_workContext.CurrentCustomer.Id, _storeContext.CurrentStore.Id)
.Where(pm => pm.PaymentMethodType == PaymentMethodType.Button)
.Where(pm => !pm.HidePaymentMethod(cart))
.ToList();
foreach (var pm in paymentMethods)
{
if (cart.IsRecurring() && pm.RecurringPaymentType == RecurringPaymentType.NotSupported)
{
continue;
}
string actionName;
string controllerName;
RouteValueDictionary routeValues;
pm.GetPaymentInfoRoute(out actionName, out controllerName, out routeValues);
model.ButtonPaymentMethodActionNames.Add(actionName);
model.ButtonPaymentMethodControllerNames.Add(controllerName);
model.ButtonPaymentMethodRouteValues.Add(routeValues);
}
#endregion
#region Order review data
if (prepareAndDisplayOrderReviewData)
{
model.OrderReviewData.Display = true;
//billing info
var billingAddress = _workContext.CurrentCustomer.BillingAddress;
if (billingAddress != null)
{
model.OrderReviewData.BillingAddress.PrepareModel(
address: billingAddress,
excludeProperties: false,
addressSettings: _addressSettings,
addressAttributeFormatter: _addressAttributeFormatter);
}
//shipping info
if (cart.RequiresShipping())
{
model.OrderReviewData.IsShippable = true;
if (_shippingSettings.AllowPickUpInStore)
{
model.OrderReviewData.SelectedPickUpInStore = _workContext.CurrentCustomer.GetAttribute <bool>(SystemCustomerAttributeNames.SelectedPickUpInStore, _storeContext.CurrentStore.Id);
}
if (!model.OrderReviewData.SelectedPickUpInStore)
{
var shippingAddress = _workContext.CurrentCustomer.ShippingAddress;
if (shippingAddress != null)
{
model.OrderReviewData.ShippingAddress.PrepareModel(
address: shippingAddress,
excludeProperties: false,
addressSettings: _addressSettings,
addressAttributeFormatter: _addressAttributeFormatter);
}
}
//selected shipping method
var shippingOption = _workContext.CurrentCustomer.GetAttribute <ShippingOption>(SystemCustomerAttributeNames.SelectedShippingOption, _storeContext.CurrentStore.Id);
if (shippingOption != null)
{
model.OrderReviewData.ShippingMethod = shippingOption.Name;
}
}
//payment info
var selectedPaymentMethodSystemName = _workContext.CurrentCustomer.GetAttribute <string>(
SystemCustomerAttributeNames.SelectedPaymentMethod, _storeContext.CurrentStore.Id);
var paymentMethod = _paymentService.LoadPaymentMethodBySystemName(selectedPaymentMethodSystemName);
model.OrderReviewData.PaymentMethod = paymentMethod != null?paymentMethod.GetLocalizedFriendlyName(_localizationService, _workContext.WorkingLanguage.Id) : "";
}
#endregion
}
public ActionResult GetCartDetails(int customerId)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageCurrentCarts))
{
return(AccessDeniedView());
}
var customer = _customerService.GetCustomerById(customerId);
var cart = customer.ShoppingCartItems.Where(x => x.ShoppingCartType == ShoppingCartType.ShoppingCart).ToList();
var gridModel = new DataSourceResult
{
Data = cart.Select(sci =>
{
decimal taxRate;
var store = _storeService.GetStoreById(sci.StoreId);
var sciModel = new ShoppingCartItemModel
{
Id = sci.Id,
Store = store != null ? store.Name : "Unknown",
ProductId = sci.ProductId,
Quantity = sci.Quantity,
ProductName = sci.Product.Name,
AttributeInfo = _productAttributeFormatter.FormatAttributes(sci.Product, sci.AttributesXml, sci.Customer),
UnitPrice = _priceFormatter.FormatPrice(_taxService.GetProductPrice(sci.Product, _priceCalculationService.GetUnitPrice(sci), out taxRate)),
Total = _priceFormatter.FormatPrice(_taxService.GetProductPrice(sci.Product, _priceCalculationService.GetSubTotal(sci), out taxRate)),
UpdatedOn = _dateTimeHelper.ConvertToUserTime(sci.UpdatedOnUtc, DateTimeKind.Utc)
};
return(sciModel);
}),
Total = cart.Count
};
return(Json(gridModel));
}
public async Task <MiniShoppingCartModel> Handle(GetMiniShoppingCart request, CancellationToken cancellationToken)
{
var model = new MiniShoppingCartModel {
ShowProductImages = _shoppingCartSettings.ShowProductImagesInMiniShoppingCart,
DisplayShoppingCartButton = true,
CurrentCustomerIsGuest = request.Customer.IsGuest(),
AnonymousCheckoutAllowed = _orderSettings.AnonymousCheckoutAllowed,
};
if (request.Customer.ShoppingCartItems.Any())
{
var shoppingCartTypes = new List <ShoppingCartType>();
shoppingCartTypes.Add(ShoppingCartType.ShoppingCart);
shoppingCartTypes.Add(ShoppingCartType.Auctions);
if (_shoppingCartSettings.AllowOnHoldCart)
{
shoppingCartTypes.Add(ShoppingCartType.OnHoldCart);
}
var cart = _shoppingCartService.GetShoppingCart(request.Store.Id, shoppingCartTypes.ToArray());
model.TotalProducts = cart.Sum(x => x.Quantity);
if (cart.Any())
{
//subtotal
var subTotalIncludingTax = request.TaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal;
var shoppingCartSubTotal = await _orderTotalCalculationService.GetShoppingCartSubTotal(cart, subTotalIncludingTax);
decimal orderSubTotalDiscountAmountBase = shoppingCartSubTotal.discountAmount;
List <AppliedDiscount> orderSubTotalAppliedDiscounts = shoppingCartSubTotal.appliedDiscounts;
decimal subTotalWithoutDiscountBase = shoppingCartSubTotal.subTotalWithoutDiscount;
decimal subTotalWithDiscountBase = shoppingCartSubTotal.subTotalWithDiscount;
decimal subtotalBase = subTotalWithoutDiscountBase;
decimal subtotal = await _currencyService.ConvertFromPrimaryStoreCurrency(subtotalBase, request.Currency);
model.SubTotal = _priceFormatter.FormatPrice(subtotal, false, request.Currency, request.Language, subTotalIncludingTax);
var requiresShipping = cart.RequiresShipping();
//a customer should visit the shopping cart page (hide checkout button) before going to checkout if:
//1. "terms of service" are enabled
//2. min order sub-total is OK
//3. we have at least one checkout attribute
var checkoutAttributesExistCacheKey = string.Format(ModelCacheEventConst.CHECKOUTATTRIBUTES_EXIST_KEY,
request.Store.Id, requiresShipping);
var checkoutAttributesExist = await _cacheManager.GetAsync(checkoutAttributesExistCacheKey, async() =>
{
var checkoutAttributes = await _checkoutAttributeService.GetAllCheckoutAttributes(request.Store.Id, !requiresShipping);
return(checkoutAttributes.Any());
});
bool minOrderSubtotalAmountOk = await _orderProcessingService.ValidateMinOrderSubtotalAmount(cart.Where
(x => x.ShoppingCartType == ShoppingCartType.ShoppingCart || x.ShoppingCartType == ShoppingCartType.Auctions).ToList());
model.DisplayCheckoutButton = !_orderSettings.TermsOfServiceOnShoppingCartPage &&
minOrderSubtotalAmountOk &&
!checkoutAttributesExist;
//products. sort descending (recently added products)
foreach (var sci in cart
.OrderByDescending(x => x.Id)
.Take(_shoppingCartSettings.MiniShoppingCartProductNumber)
.ToList())
{
var product = await _productService.GetProductById(sci.ProductId);
if (product == null)
{
continue;
}
var cartItemModel = new MiniShoppingCartModel.ShoppingCartItemModel {
Id = sci.Id,
ProductId = product.Id,
ProductName = product.GetLocalized(x => x.Name, request.Language.Id),
ProductSeName = product.GetSeName(request.Language.Id),
Quantity = sci.Quantity,
AttributeInfo = await _productAttributeFormatter.FormatAttributes(product, sci.AttributesXml)
};
if (product.ProductType == ProductType.Reservation)
{
var reservation = "";
if (sci.RentalEndDateUtc == default(DateTime) || sci.RentalEndDateUtc == null)
{
reservation = string.Format(_localizationService.GetResource("ShoppingCart.Reservation.StartDate"), sci.RentalStartDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
else
{
reservation = string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Date"), sci.RentalStartDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat), sci.RentalEndDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
if (!string.IsNullOrEmpty(sci.Parameter))
{
reservation += "<br>" + string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Option"), sci.Parameter);
}
if (!string.IsNullOrEmpty(sci.Duration))
{
reservation += "<br>" + string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Duration"), sci.Duration);
}
if (string.IsNullOrEmpty(cartItemModel.AttributeInfo))
{
cartItemModel.AttributeInfo = reservation;
}
else
{
cartItemModel.AttributeInfo += "<br>" + reservation;
}
}
//unit prices
if (product.CallForPrice)
{
cartItemModel.UnitPrice = _localizationService.GetResource("Products.CallForPrice");
}
else
{
var productprices = await _taxService.GetProductPrice(product, (await _priceCalculationService.GetUnitPrice(sci)).unitprice);
decimal taxRate = productprices.taxRate;
decimal shoppingCartUnitPriceWithDiscountBase = productprices.productprice;
decimal shoppingCartUnitPriceWithDiscount = await _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartUnitPriceWithDiscountBase, request.Currency);
cartItemModel.UnitPrice = _priceFormatter.FormatPrice(shoppingCartUnitPriceWithDiscount);
}
//picture
if (_shoppingCartSettings.ShowProductImagesInMiniShoppingCart)
{
cartItemModel.Picture = await PrepareCartItemPicture(request, product, sci.AttributesXml);
}
model.Items.Add(cartItemModel);
}
}
}
return(model);
}
public IActionResult GetCartDetails(string customerId)
{
var customer = _customerService.GetCustomerById(customerId);
var cart = customer.ShoppingCartItems.Where(x => x.ShoppingCartType == ShoppingCartType.ShoppingCart).ToList();
var gridModel = new DataSourceResult
{
Data = cart.Select(sci =>
{
decimal taxRate;
var store = _storeService.GetStoreById(sci.StoreId);
var product = EngineContext.Current.Resolve <IProductService>().GetProductById(sci.ProductId);
var sciModel = new ShoppingCartItemModel
{
Id = sci.Id,
Store = store != null ? store.Name : "Unknown",
ProductId = sci.ProductId,
Quantity = sci.Quantity,
ProductName = product.Name,
AttributeInfo = _productAttributeFormatter.FormatAttributes(product, sci.AttributesXml, customer),
UnitPrice = _priceFormatter.FormatPrice(_taxService.GetProductPrice(product, _priceCalculationService.GetUnitPrice(sci), out taxRate)),
Total = _priceFormatter.FormatPrice(_taxService.GetProductPrice(product, _priceCalculationService.GetSubTotal(sci), out taxRate)),
UpdatedOn = _dateTimeHelper.ConvertToUserTime(sci.UpdatedOnUtc, DateTimeKind.Utc)
};
return(sciModel);
}),
Total = cart.Count
};
return(Json(gridModel));
}
public SetExpressCheckoutResponseType SetExpressCheckout(PayPalProcessPaymentRequest processPaymentRequest, IList <OrganizedShoppingCartItem> cart)
{
var result = new SetExpressCheckoutResponseType();
var store = Services.StoreService.GetStoreById(processPaymentRequest.StoreId);
var customer = Services.WorkContext.CurrentCustomer;
var settings = Services.Settings.LoadSetting <PayPalExpressPaymentSettings>(processPaymentRequest.StoreId);
var payPalCurrency = GetApiCurrency(store.PrimaryStoreCurrency);
var excludingTax = (Services.WorkContext.GetTaxDisplayTypeFor(customer, store.Id) == TaxDisplayType.ExcludingTax);
var req = new SetExpressCheckoutReq
{
SetExpressCheckoutRequest = new SetExpressCheckoutRequestType
{
Version = ApiVersion,
SetExpressCheckoutRequestDetails = new SetExpressCheckoutRequestDetailsType()
}
};
var details = new SetExpressCheckoutRequestDetailsType
{
PaymentAction = GetPaymentAction(settings),
PaymentActionSpecified = true,
CancelURL = Services.WebHelper.GetStoreLocation(store.SslEnabled) + "cart",
ReturnURL = Services.WebHelper.GetStoreLocation(store.SslEnabled) + "Plugins/SmartStore.PayPal/PayPalExpress/GetDetails",
//CallbackURL = _webHelper.GetStoreLocation(currentStore.SslEnabled) + "Plugins/SmartStore.PayPal/PayPalExpress/ShippingOptions?CustomerID=" + _workContext.CurrentCustomer.Id.ToString(),
//CallbackTimeout = _payPalExpressPaymentSettings.CallbackTimeout.ToString()
ReqConfirmShipping = settings.ConfirmedShipment.ToString(),
NoShipping = settings.NoShipmentAddress.ToString()
};
// populate cart
var taxRate = decimal.Zero;
var unitPriceTaxRate = decimal.Zero;
var itemTotal = decimal.Zero;
var cartItems = new List <PaymentDetailsItemType>();
foreach (var item in cart)
{
var product = item.Item.Product;
var unitPrice = _priceCalculationService.GetUnitPrice(item, true);
var shoppingCartUnitPriceWithDiscount = excludingTax
? _taxService.GetProductPrice(product, unitPrice, false, customer, out taxRate)
: _taxService.GetProductPrice(product, unitPrice, true, customer, out unitPriceTaxRate);
cartItems.Add(new PaymentDetailsItemType
{
Name = product.Name,
Number = product.Sku,
Quantity = item.Item.Quantity.ToString(),
// this is the per item cost
Amount = new BasicAmountType
{
currencyID = payPalCurrency,
Value = shoppingCartUnitPriceWithDiscount.FormatInvariant()
}
});
itemTotal += (item.Item.Quantity * shoppingCartUnitPriceWithDiscount);
}
;
// additional handling fee
var additionalHandlingFee = GetAdditionalHandlingFee(cart);
cartItems.Add(new PaymentDetailsItemType
{
Name = T("Plugins.Payments.PayPal.PaymentMethodFee").Text,
Quantity = "1",
Amount = new BasicAmountType()
{
currencyID = payPalCurrency,
Value = additionalHandlingFee.FormatInvariant()
}
});
itemTotal += GetAdditionalHandlingFee(cart);
//shipping
var shippingTotal = decimal.Zero;
if (cart.RequiresShipping())
{
decimal?shoppingCartShippingBase = OrderTotalCalculationService.GetShoppingCartShippingTotal(cart);
if (shoppingCartShippingBase.HasValue && shoppingCartShippingBase > 0)
{
shippingTotal = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartShippingBase.Value, Services.WorkContext.WorkingCurrency);
}
else
{
shippingTotal = settings.DefaultShippingPrice;
}
}
//This is the default if the Shipping Callback fails
//var shippingOptions = new List<ShippingOptionType>();
//shippingOptions.Add(new ShippingOptionType()
//{
// ShippingOptionIsDefault = "true",
// ShippingOptionName = "Standard Shipping",
// ShippingOptionAmount = new BasicAmountType()
// {
// Value = shippingTotal.ToString(), //This is the default value used for shipping if the Instant Update API returns an error or does not answer within the callback time
// currencyID = PaypalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId))
// }
//});
//details.FlatRateShippingOptions = shippingOptions.ToArray();
//details.TotalType = TotalType.EstimatedTotal;
// get total tax
//SortedDictionary<decimal, decimal> taxRates = null;
//decimal shoppingCartTaxBase = OrderTotalCalculationService.GetTaxTotal(cart, out taxRates);
//decimal shoppingCartTax = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartTaxBase, CommonServices.WorkContext.WorkingCurrency);
// discount
var discount = -processPaymentRequest.Discount;
if (discount != 0)
{
cartItems.Add(new PaymentDetailsItemType
{
Name = T("Plugins.Payments.PayPal.ThreadrockDiscount").Text,
Quantity = "1",
Amount = new BasicAmountType // this is the total discount
{
currencyID = payPalCurrency,
Value = discount.FormatInvariant()
}
});
itemTotal += discount;
}
if (!cart.IsRecurring())
{
//we don't apply gift cards for recurring products
var giftCards = _giftCardService.GetActiveGiftCardsAppliedByCustomer(customer, Services.StoreContext.CurrentStore.Id);
if (giftCards != null)
{
foreach (var gc in giftCards)
{
if (itemTotal > decimal.Zero)
{
decimal remainingAmount = gc.GetGiftCardRemainingAmount();
decimal amountCanBeUsed = decimal.Zero;
if (itemTotal > remainingAmount)
{
amountCanBeUsed = remainingAmount;
}
else
{
amountCanBeUsed = itemTotal - .01M;
}
decimal amountToSubtract = -amountCanBeUsed;
cartItems.Add(new PaymentDetailsItemType
{
Name = T("Plugins.Payments.PayPal.GiftcardApplied").Text,
Quantity = "1",
Amount = new BasicAmountType
{
currencyID = payPalCurrency,
Value = amountToSubtract.FormatInvariant()
}
});
//reduce subtotal
itemTotal += amountToSubtract;
}
}
}
}
// populate payment details
var paymentDetails = new PaymentDetailsType
{
ItemTotal = new BasicAmountType
{
Value = Math.Round(itemTotal, 2).FormatInvariant(),
currencyID = payPalCurrency
},
ShippingTotal = new BasicAmountType
{
Value = Math.Round(shippingTotal, 2).FormatInvariant(),
currencyID = payPalCurrency
},
//TaxTotal = new BasicAmountType
//{
// Value = Math.Round(shoppingCartTax, 2).ToString("N", new CultureInfo("en-us")),
// currencyID = PayPalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId))
//},
OrderTotal = new BasicAmountType
{
Value = Math.Round(itemTotal + shippingTotal, 2).FormatInvariant(),
currencyID = payPalCurrency
},
Custom = processPaymentRequest.OrderGuid.ToString(),
ButtonSource = SmartStoreVersion.CurrentFullVersion,
PaymentAction = GetPaymentAction(settings),
PaymentDetailsItem = cartItems.ToArray()
};
details.PaymentDetails = new[] { paymentDetails };
details.ShippingMethodSpecified = true;
req.SetExpressCheckoutRequest.SetExpressCheckoutRequestDetails.Custom = processPaymentRequest.OrderGuid.ToString();
req.SetExpressCheckoutRequest.SetExpressCheckoutRequestDetails = details;
using (var service = GetApiAaService(settings))
{
result = service.SetExpressCheckout(req);
}
var checkoutState = _httpContext.GetCheckoutState();
if (checkoutState.CustomProperties.ContainsKey("PayPalExpressButtonUsed"))
{
checkoutState.CustomProperties["PayPalExpressButtonUsed"] = true;
}
else
{
checkoutState.CustomProperties.Add("PayPalExpressButtonUsed", true);
}
return(result);
}
public ActionResult GetCartDetails(int customerId)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageOrders))
{
return(AccessDeniedView());
}
var customer = _customerService.GetCustomerById(customerId);
var cart = customer.ShoppingCartItems.Where(x => x.ShoppingCartType == ShoppingCartType.ShoppingCart).ToList();
var gridModel = new GridModel <ShoppingCartItemModel>()
{
Data = cart.Select(sci =>
{
decimal taxRate;
var sciModel = new ShoppingCartItemModel()
{
Id = sci.Id,
Store = sci.Store != null ? sci.Store.Name : "Unknown",
ProductVariantId = sci.ProductVariantId,
Quantity = sci.Quantity,
FullProductName = !String.IsNullOrEmpty(sci.ProductVariant.Name) ?
string.Format("{0} ({1})", sci.ProductVariant.Product.Name, sci.ProductVariant.Name) :
sci.ProductVariant.Product.Name,
UnitPrice = _priceFormatter.FormatPrice(_taxService.GetProductPrice(sci.ProductVariant, _priceCalculationService.GetUnitPrice(sci, true), out taxRate)),
Total = _priceFormatter.FormatPrice(_taxService.GetProductPrice(sci.ProductVariant, _priceCalculationService.GetSubTotal(sci, true), out taxRate)),
UpdatedOn = _dateTimeHelper.ConvertToUserTime(sci.UpdatedOnUtc, DateTimeKind.Utc)
};
return(sciModel);
}),
Total = cart.Count
};
return(new JsonResult
{
Data = gridModel
});
}
public async Task <IActionResult> GetCartDetails(string customerId)
{
var customer = await _customerService.GetCustomerById(customerId);
var cart = customer.ShoppingCartItems.Where(x => x.ShoppingCartType == ShoppingCartType.ShoppingCart).ToList();
var items = new List <ShoppingCartItemModel>();
foreach (var sci in cart)
{
var store = await _storeService.GetStoreById(sci.StoreId);
var product = await _productService.GetProductById(sci.ProductId);
var sciModel = new ShoppingCartItemModel {
Id = sci.Id,
Store = store != null ? store.Shortcut : "Unknown",
ProductId = sci.ProductId,
Quantity = sci.Quantity,
ProductName = product.Name,
AttributeInfo = await _productAttributeFormatter.FormatAttributes(product, sci.AttributesXml, customer),
UnitPrice = _priceFormatter.FormatPrice((await _taxService.GetProductPrice(product, (await _priceCalculationService.GetUnitPrice(sci, product)).unitprice)).productprice),
Total = _priceFormatter.FormatPrice((await _taxService.GetProductPrice(product, (await _priceCalculationService.GetSubTotal(sci, product)).subTotal)).productprice),
UpdatedOn = _dateTimeHelper.ConvertToUserTime(sci.UpdatedOnUtc, DateTimeKind.Utc)
};
items.Add(sciModel);
}
var gridModel = new DataSourceResult {
Data = items,
Total = cart.Count
};
return(Json(gridModel));
}
public PayPalResponse CreatePayment(
PayPalApiSettingsBase settings,
PayPalSessionData session,
List <OrganizedShoppingCartItem> cart,
string providerSystemName,
string returnUrl,
string cancelUrl)
{
var store = _services.StoreContext.CurrentStore;
var customer = _services.WorkContext.CurrentCustomer;
var language = _services.WorkContext.WorkingLanguage;
var currencyCode = store.PrimaryStoreCurrency.CurrencyCode;
var dateOfBirth = customer.GetAttribute <DateTime?>(SystemCustomerAttributeNames.DateOfBirth);
Discount orderAppliedDiscount;
List <AppliedGiftCard> appliedGiftCards;
int redeemedRewardPoints = 0;
decimal redeemedRewardPointsAmount;
decimal orderDiscountInclTax;
decimal totalOrderItems = decimal.Zero;
var includingTax = (_services.WorkContext.GetTaxDisplayTypeFor(customer, store.Id) == TaxDisplayType.IncludingTax);
var shipping = (_orderTotalCalculationService.GetShoppingCartShippingTotal(cart) ?? decimal.Zero);
var paymentFee = _paymentService.GetAdditionalHandlingFee(cart, providerSystemName);
var total = (_orderTotalCalculationService.GetShoppingCartTotal(cart, out orderDiscountInclTax, out orderAppliedDiscount, out appliedGiftCards,
out redeemedRewardPoints, out redeemedRewardPointsAmount) ?? decimal.Zero);
var data = new Dictionary <string, object>();
var redirectUrls = new Dictionary <string, object>();
var payer = new Dictionary <string, object>();
var payerInfo = new Dictionary <string, object>();
var transaction = new Dictionary <string, object>();
var amount = new Dictionary <string, object>();
var amountDetails = new Dictionary <string, object>();
var items = new List <Dictionary <string, object> >();
var itemList = new Dictionary <string, object>();
// "PayPal PLUS only supports transaction type “Sale” (instant settlement)"
if (providerSystemName == PayPalPlusProvider.SystemName)
{
data.Add("intent", "sale");
}
else
{
data.Add("intent", settings.TransactMode == TransactMode.AuthorizeAndCapture ? "sale" : "authorize");
}
if (settings.ExperienceProfileId.HasValue())
{
data.Add("experience_profile_id", settings.ExperienceProfileId);
}
// redirect urls
if (returnUrl.HasValue())
{
redirectUrls.Add("return_url", returnUrl);
}
if (cancelUrl.HasValue())
{
redirectUrls.Add("cancel_url", cancelUrl);
}
if (redirectUrls.Any())
{
data.Add("redirect_urls", redirectUrls);
}
// payer, payer_info
if (dateOfBirth.HasValue)
{
payerInfo.Add("birth_date", dateOfBirth.Value.ToString("yyyy-MM-dd"));
}
if (customer.BillingAddress != null)
{
payerInfo.Add("billing_address", CreateAddress(customer.BillingAddress, false));
}
payer.Add("payment_method", "paypal");
payer.Add("payer_info", payerInfo);
data.Add("payer", payer);
// line items
foreach (var item in cart)
{
decimal unitPriceTaxRate = decimal.Zero;
decimal unitPrice = _priceCalculationService.GetUnitPrice(item, true);
decimal productPrice = _taxService.GetProductPrice(item.Item.Product, unitPrice, includingTax, customer, out unitPriceTaxRate);
var line = new Dictionary <string, object>();
line.Add("quantity", item.Item.Quantity);
line.Add("name", item.Item.Product.GetLocalized(x => x.Name, language.Id, true, false).Truncate(127));
line.Add("price", productPrice.FormatInvariant());
line.Add("currency", currencyCode);
line.Add("sku", item.Item.Product.Sku.Truncate(50));
items.Add(line);
totalOrderItems += (productPrice * item.Item.Quantity);
}
var itemsPlusMisc = (totalOrderItems + shipping + paymentFee);
if (total != itemsPlusMisc)
{
var line = new Dictionary <string, object>();
line.Add("quantity", "1");
line.Add("name", T("Plugins.SmartStore.PayPal.Other").Text.Truncate(127));
line.Add("price", (total - itemsPlusMisc).FormatInvariant());
line.Add("currency", currencyCode);
items.Add(line);
totalOrderItems += (total - itemsPlusMisc);
}
itemList.Add("items", items);
if (customer.ShippingAddress != null)
{
itemList.Add("shipping_address", CreateAddress(customer.ShippingAddress, true));
}
// transactions
amountDetails.Add("shipping", shipping.FormatInvariant());
amountDetails.Add("subtotal", totalOrderItems.FormatInvariant());
if (!includingTax)
{
// "To avoid rounding errors we recommend not submitting tax amounts on line item basis.
// Calculated tax amounts for the entire shopping basket may be submitted in the amount objects.
// In this case the item amounts will be treated as amounts excluding tax.
// In a B2C scenario, where taxes are included, no taxes should be submitted to PayPal."
SortedDictionary <decimal, decimal> taxRates = null;
var taxTotal = _orderTotalCalculationService.GetTaxTotal(cart, out taxRates);
amountDetails.Add("tax", taxTotal.FormatInvariant());
}
if (paymentFee != decimal.Zero)
{
amountDetails.Add("handling_fee", paymentFee.FormatInvariant());
}
amount.Add("total", total.FormatInvariant());
amount.Add("currency", currencyCode);
amount.Add("details", amountDetails);
transaction.Add("amount", amount);
transaction.Add("item_list", itemList);
transaction.Add("invoice_number", session.OrderGuid.ToString());
data.Add("transactions", new List <Dictionary <string, object> > {
transaction
});
var result = CallApi("POST", "/v1/payments/payment", session.AccessToken, settings, JsonConvert.SerializeObject(data));
if (result.Success && result.Json != null)
{
result.Id = (string)result.Json.id;
}
//Logger.InsertLog(LogLevel.Information, "PayPal PLUS", JsonConvert.SerializeObject(data, Formatting.Indented) + "\r\n\r\n" + (result.Json != null ? result.Json.ToString() : ""));
return(result);
}
private PaymentMessage GetPaymentoMessage(PayPalPlusBrasilPaymentSettings payPalPlusBrasilPaymentSettings, Customer customer)
{
var cart = _workContext.CurrentCustomer.ShoppingCartItems.
Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart)
.LimitPerStore(_storeContext.CurrentStore.Id)
.ToList();
List <AppliedGiftCard> appliedGiftCards;
List <Discount> orderAppliedDiscounts;
decimal orderDiscountAmount;
int redeemedRewardPoints;
decimal redeemedRewardPointsAmount;
var orderTotal = _orderTotalCalculationService.GetShoppingCartTotal(cart, out orderDiscountAmount,
out orderAppliedDiscounts, out appliedGiftCards, out redeemedRewardPoints, out redeemedRewardPointsAmount);
decimal tax;
List <Discount> shippingTotalDiscounts;
var orderShippingTotalInclTax = _orderTotalCalculationService.GetShoppingCartShippingTotal(cart, true, out tax, out shippingTotalDiscounts);
decimal orderSubTotalDiscountAmount;
List <Discount> orderSubTotalAppliedDiscounts;
decimal subTotalWithoutDiscountBase;
decimal subTotalWithDiscountBase;
_orderTotalCalculationService.GetShoppingCartSubTotal(cart, true, out orderSubTotalDiscountAmount,
out orderSubTotalAppliedDiscounts, out subTotalWithoutDiscountBase, out subTotalWithDiscountBase);
var paymentMessage = new PaymentMessage();
paymentMessage.Intent = "sale";
paymentMessage.Payer.PaymentMethod = "paypal";
paymentMessage.ExperienceProfileId = payPalPlusBrasilPaymentSettings.IdProfileExperience;
var transactionList = new List <Models.Message.Request.Transaction>();
var itemTransaction = new Models.Message.Request.Transaction();
itemTransaction.Amount.Currency = "BRL";
itemTransaction.Amount.Total = orderTotal.Value.ToString("N", new CultureInfo("en-US"));
itemTransaction.Amount.Details.Shipping = orderShippingTotalInclTax.Value.ToString("N", new CultureInfo("en-US"));
itemTransaction.Amount.Details.Subtotal = subTotalWithoutDiscountBase.ToString("N", new CultureInfo("en-US"));
itemTransaction.Amount.Details.Discount = (orderDiscountAmount + orderSubTotalDiscountAmount).ToString("N", new CultureInfo("en-US"));
itemTransaction.Description = "This is the payment transaction description";
itemTransaction.PaymentOptions.AllowedPaymentMethod = "IMMEDIATE_PAY";
itemTransaction.InvoiceNumber = string.Empty;
var number = string.Empty;
var complement = string.Empty;
new AddressHelper(_addressAttributeParser, _workContext).GetCustomNumberAndComplement(customer.ShippingAddress.CustomAttributes,
out number, out complement);
itemTransaction.ItemList.ShippingAddress.RecipientName = AddressHelper.GetFullName(customer.ShippingAddress);
itemTransaction.ItemList.ShippingAddress.Line1 = customer.ShippingAddress.Address1;
itemTransaction.ItemList.ShippingAddress.Line2 = complement;
itemTransaction.ItemList.ShippingAddress.City = customer.ShippingAddress.City;
itemTransaction.ItemList.ShippingAddress.CountryCode = customer.ShippingAddress.Country.TwoLetterIsoCode;
itemTransaction.ItemList.ShippingAddress.PostalCode = customer.ShippingAddress.ZipPostalCode;
itemTransaction.ItemList.ShippingAddress.State = customer.ShippingAddress.StateProvince.Name;
itemTransaction.ItemList.ShippingAddress.Phone = AddressHelper.FormatarCelular(customer.ShippingAddress.PhoneNumber);
var itemList = new List <Models.Message.Request.Item>();
foreach (var itemCart in cart)
{
var item = new Models.Message.Request.Item();
item.Name = itemCart.Product.Name;
item.Description = itemCart.Product.ShortDescription;
item.Quantity = itemCart.Quantity;
List <Discount> scDiscounts;
decimal discountAmount;
var scUnitPrice = _priceCalculationService.GetUnitPrice(itemCart, true, out discountAmount, out scDiscounts);
item.Price = decimal.Round(scUnitPrice, 2).ToString("N2", new CultureInfo("en-US"));
item.Sku = itemCart.Product.Sku;
item.Currency = "BRL";
itemList.Add(item);
}
itemTransaction.ItemList.Items = itemList.ToArray();
transactionList.Add(itemTransaction);
paymentMessage.Transactions = transactionList.ToArray();
string returnUrl = _webHelper.GetStoreLocation(false) + "Plugins/PaymentPayPalPlusBrasil/IPNHandler";
string cancelReturnUrl = _webHelper.GetStoreLocation(false) + "Plugins/PaymentPayPalPlusBrasil/IPNHandler";
paymentMessage.RedirectUrls.ReturnUrl = new Uri(returnUrl);
paymentMessage.RedirectUrls.CancelUrl = new Uri(cancelReturnUrl);
return(paymentMessage);
}
/// <summary>
/// Post cart to google
/// </summary>
/// <param name="req">Pre-generated request</param>
/// <param name="cart">Shopping cart</param>
/// <returns>Response</returns>
public GCheckoutResponse PostCartToGoogle(CheckoutShoppingCartRequest req,
IList <Core.Domain.Orders.ShoppingCartItem> cart)
{
//there's no need to round prices (Math.Round(,2)) because GCheckout library does it for us
//items
foreach (Core.Domain.Orders.ShoppingCartItem sci in cart)
{
var productVariant = sci.ProductVariant;
if (productVariant != null)
{
decimal taxRate = decimal.Zero;
string description = _productAttributeFormatter.FormatAttributes(productVariant, sci.AttributesXml, _workContext.CurrentCustomer, ", ", false);
string fullName = "";
if (!String.IsNullOrEmpty(sci.ProductVariant.GetLocalized(x => x.Name)))
{
fullName = string.Format("{0} ({1})", sci.ProductVariant.Product.GetLocalized(x => x.Name), sci.ProductVariant.GetLocalized(x => x.Name));
}
else
{
fullName = sci.ProductVariant.Product.GetLocalized(x => x.Name);
}
decimal unitPrice = _taxService.GetProductPrice(sci.ProductVariant, _priceCalculationService.GetUnitPrice(sci, true), out taxRate);
req.AddItem(fullName, description, sci.Id.ToString(), unitPrice, sci.Quantity);
}
}
if (cart.RequiresShipping())
{
//AddMerchantCalculatedShippingMethod
//AddCarrierCalculatedShippingOption
var shippingOptions = _shippingService.GetShippingOptions(cart, null);
foreach (ShippingOption shippingOption in shippingOptions.ShippingOptions)
{
req.AddFlatRateShippingMethod(shippingOption.Name, _taxService.GetShippingPrice(shippingOption.Rate, _workContext.CurrentCustomer));
}
}
//add only US, GB states
//CountryCollection countries = IoC.Resolve<ICountryService>().GetAllCountries();
//foreach (Country country in countries)
//{
// foreach (StateProvince state in country.StateProvinces)
// {
// TaxByStateProvinceCollection taxByStateProvinceCollection = TaxByIoC.Resolve<IStateProvinceService>().GetAllByStateProvinceID(state.StateProvinceID);
// foreach (TaxByStateProvince taxByStateProvince in taxByStateProvinceCollection)
// {
// if (!String.IsNullOrEmpty(state.Abbreviation))
// {
// Req.AddStateTaxRule(state.Abbreviation, (double)taxByStateProvince.Percentage, false);
// }
// }
// }
//}
//if (subTotalDiscountBase > decimal.Zero)
//{
// req.AddItem("Discount", string.Empty, string.Empty, (decimal)(-1.0) * subTotalDiscountBase, 1);
//}
//foreach (AppliedGiftCard agc in appliedGiftCards)
//{
// req.AddItem(string.Format("Gift Card - {0}", agc.GiftCard.GiftCardCouponCode), string.Empty, string.Empty, (decimal)(-1.0) * agc.AmountCanBeUsed, 1);
//}
var customerInfoDoc = new XmlDocument();
XmlElement customerInfo = customerInfoDoc.CreateElement("CustomerInfo");
customerInfo.SetAttribute("CustomerID", _workContext.CurrentCustomer.Id.ToString());
customerInfo.SetAttribute("CustomerLanguageID", _workContext.WorkingLanguage.Id.ToString());
customerInfo.SetAttribute("CustomerCurrencyID", _workContext.WorkingCurrency.Id.ToString());
req.AddMerchantPrivateDataNode(customerInfo);
req.ContinueShoppingUrl = _webHelper.GetStoreLocation(false);
req.EditCartUrl = _webHelper.GetStoreLocation(false) + "cart";
GCheckoutResponse resp = req.Send();
return(resp);
}
private bool CheckCurrentSubTotalRequirement(CheckDiscountRequirementRequest request)
{
var spentAmount = decimal.Zero;
try
{
var taxRate = decimal.Zero;
var cartItems = request.Customer.GetCartItems(ShoppingCartType.ShoppingCart, request.Store.Id);
foreach (var cartItem in cartItems)
{
var product = cartItem.Item.Product;
Dictionary <string, object> mergedValuesClone = null;
// we must reapply merged values because CheckCurrentSubTotalRequirement uses price calculation and is called by it itself.
// this can cause wrong discount calculation if the cart contains a product several times.
if (product.MergedDataValues != null)
{
mergedValuesClone = new Dictionary <string, object>(product.MergedDataValues);
}
// includeDiscounts == true produces a stack overflow!
spentAmount += cartItem.Item.Quantity * _taxService.GetProductPrice(product, _priceCalculationService.GetUnitPrice(cartItem, false), out taxRate);
if (mergedValuesClone != null)
{
product.MergedDataValues = new Dictionary <string, object>(mergedValuesClone);
}
}
}
catch (Exception exception)
{
_logger.Error(exception);
return(false);
}
return(spentAmount >= request.DiscountRequirement.SpentAmount);
}