Open-source eCommerce platform for C# and ASP.NET Core 10 with MongoDB. Build multi-store shops and multi-vendor marketplaces with B2B/B2C, REST API, plugins, Vue 3 and Docker.
C# aspnet-corecsharpdockerdotnetecommerceecommerce-platformmongodbmulti-storemulti-vendornosqlonline-shopshoppingcart
using Grand.Business.Core.Commands.Checkout.Orders;
using Grand.Business.Core.Extensions;
using Grand.Business.Core.Interfaces.Catalog.Discounts;
using Grand.Business.Core.Interfaces.Catalog.Prices;
using Grand.Business.Core.Interfaces.Catalog.Products;
using Grand.Business.Core.Interfaces.Catalog.Tax;
using Grand.Business.Core.Interfaces.Checkout.CheckoutAttributes;
using Grand.Business.Core.Interfaces.Checkout.Orders;
using Grand.Business.Core.Interfaces.Checkout.Shipping;
using Grand.Business.Core.Interfaces.Common.Directory;
using Grand.Business.Core.Interfaces.Common.Localization;
using Grand.Business.Core.Interfaces.Common.Security;
using Grand.Business.Core.Interfaces.Customers;
using Grand.Business.Core.Interfaces.Storage;
using Grand.Business.Core.Utilities.Checkout;
using Grand.Domain.Permissions;
using Grand.Domain.Catalog;
using Grand.Domain.Common;
using Grand.Domain.Customers;
using Grand.Domain.Media;
using Grand.Domain.Orders;
using Grand.Web.Common.Localization;
using Grand.Web.Extensions;
using Grand.Web.Features.Models.ShoppingCart;
using Grand.Web.Models.Media;
using Grand.Web.Models.ShoppingCart;
using Grand.Mediator;
using Microsoft.AspNetCore.Mvc.Rendering;
namespace Grand.Web.Features.Handlers.ShoppingCart;
public class GetShoppingCartHandler : IRequestHandler<GetShoppingCart, ShoppingCartModel>
{
private readonly CatalogSettings _catalogSettings;
private readonly ICheckoutAttributeFormatter _checkoutAttributeFormatter;
private readonly ICheckoutAttributeParser _checkoutAttributeParser;
private readonly ICheckoutAttributeService _checkoutAttributeService;
private readonly CommonSettings _commonSettings;
private readonly ICurrencyService _currencyService;
private readonly IDateTimeService _dateTimeService;
private readonly IDiscountService _discountService;
private readonly IDiscountValidationService _discountValidationService;
private readonly IDownloadService _downloadService;
private readonly IGroupService _groupService;
private readonly LinkGenerator _linkGenerator;
private readonly MediaSettings _mediaSettings;
private readonly IMediator _mediator;
private readonly OrderSettings _orderSettings;
private readonly IPermissionService _permissionService;
private readonly IPictureService _pictureService;
private readonly IPriceFormatter _priceFormatter;
private readonly IPricingService _pricingService;
private readonly IProductAttributeFormatter _productAttributeFormatter;
private readonly IProductService _productService;
private readonly ShoppingCartSettings _shoppingCartSettings;
private readonly IShoppingCartValidator _shoppingCartValidator;
private readonly ITaxService _taxService;
private readonly ITranslationService _translationService;
private readonly IVendorService _vendorService;
private readonly IWarehouseService _warehouseService;
private readonly IEnumTranslationService _enumTranslationService;
public GetShoppingCartHandler(
IProductService productService,
IPictureService pictureService,
ITranslationService translationService,
ICheckoutAttributeFormatter checkoutAttributeFormatter,
ICurrencyService currencyService,
IDiscountService discountService,
ICheckoutAttributeService checkoutAttributeService,
IPermissionService permissionService,
ITaxService taxService,
IPriceFormatter priceFormatter,
ICheckoutAttributeParser checkoutAttributeParser,
IDownloadService downloadService,
IWarehouseService warehouseService,
IProductAttributeFormatter productAttributeFormatter,
IPricingService priceCalculationService,
IDateTimeService dateTimeService,
IVendorService vendorService,
IGroupService groupService,
IMediator mediator,
IShoppingCartValidator shoppingCartValidator,
IDiscountValidationService discountValidationService,
LinkGenerator linkGenerator,
MediaSettings mediaSettings,
OrderSettings orderSettings,
ShoppingCartSettings shoppingCartSettings,
CatalogSettings catalogSettings,
CommonSettings commonSettings,
IEnumTranslationService enumTranslationService)
{
_productService = productService;
_pictureService = pictureService;
_translationService = translationService;
_checkoutAttributeFormatter = checkoutAttributeFormatter;
_currencyService = currencyService;
_discountService = discountService;
_checkoutAttributeService = checkoutAttributeService;
_permissionService = permissionService;
_taxService = taxService;
_priceFormatter = priceFormatter;
_checkoutAttributeParser = checkoutAttributeParser;
_downloadService = downloadService;
_warehouseService = warehouseService;
_productAttributeFormatter = productAttributeFormatter;
_pricingService = priceCalculationService;
_dateTimeService = dateTimeService;
_vendorService = vendorService;
_groupService = groupService;
_mediator = mediator;
_shoppingCartValidator = shoppingCartValidator;
_discountValidationService = discountValidationService;
_linkGenerator = linkGenerator;
_mediaSettings = mediaSettings;
_orderSettings = orderSettings;
_shoppingCartSettings = shoppingCartSettings;
_catalogSettings = catalogSettings;
_commonSettings = commonSettings;
_enumTranslationService = enumTranslationService;
}
public async Task<ShoppingCartModel> Handle(GetShoppingCart request, CancellationToken cancellationToken)
{
var model = new ShoppingCartModel();
if (!request.Cart.Any())
return model;
await PrepareSimpleProperties(model, request);
await PrepareCheckoutAttributes(model, request);
await PrepareCartItems(model, request);
return model;
}
private async Task PrepareSimpleProperties(ShoppingCartModel model, GetShoppingCart request)
{
#region Simple properties
model.IsEditable = request.IsEditable;
model.IsAllowOnHold = _shoppingCartSettings.AllowOnHoldCart;
model.TermsOfServicePopup = _commonSettings.PopupForTermsOfServiceLinks;
model.ShowProductImages = _shoppingCartSettings.ShowProductImagesOnShoppingCart;
model.ShowSku = _catalogSettings.ShowSkuOnProductDetailsPage;
model.IsGuest = await _groupService.IsGuest(request.Customer);
model.ShowCheckoutAsGuestButton = model.IsGuest && _orderSettings.AnonymousCheckoutAllowed;
var checkoutAttributes =
request.Customer.GetUserFieldFromEntity<List<CustomAttribute>>(SystemCustomerFieldNames.CheckoutAttributes,
request.Store.Id);
model.CheckoutAttributeInfo =
await _checkoutAttributeFormatter.FormatAttributes(checkoutAttributes, request.Customer, request.Store);
if (!request.Cart.Where(x => x.ShoppingCartTypeId is ShoppingCartType.ShoppingCart or ShoppingCartType.Auctions)
.ToList().Any())
{
model.MinOrderSubtotalWarning = _translationService.GetResource("Checkout.MinOrderOneProduct");
}
else
{
var minOrderSubtotalAmountOk = await _mediator.Send(new ValidateMinShoppingCartSubtotalAmountCommand {
Customer = request.Customer,
Cart = request.Cart.Where(x =>
x.ShoppingCartTypeId is ShoppingCartType.ShoppingCart or ShoppingCartType.Auctions).ToList()
});
if (!minOrderSubtotalAmountOk)
{
var minOrderSubtotalAmount =
await _currencyService.ConvertFromPrimaryStoreCurrency(_orderSettings.MinOrderSubtotalAmount,
request.Currency);
model.MinOrderSubtotalWarning =
string.Format(_translationService.GetResource("Checkout.MinOrderSubtotalAmount"),
_priceFormatter.FormatPrice(minOrderSubtotalAmount, request.Currency));
}
}
model.TermsOfServiceOnShoppingCartPage = _orderSettings.TermsOfServiceOnShoppingCartPage;
model.TermsOfServiceOnOrderConfirmPage = _orderSettings.TermsOfServiceOnOrderConfirmPage;
model.DiscountBox.Display = _shoppingCartSettings.ShowDiscountBox;
var discountCouponCodes = request.Customer.ParseAppliedCouponCodes(SystemCustomerFieldNames.DiscountCoupons);
foreach (var couponCode in discountCouponCodes)
{
var discount = await _discountService.GetDiscountByCouponCode(couponCode);
if (discount is { RequiresCouponCode: true } &&
(await _discountValidationService.ValidateDiscount(discount, request.Customer, request.Store,
request.Currency)).IsValid)
model.DiscountBox.AppliedDiscountsWithCodes.Add(new ShoppingCartModel.DiscountBoxModel.DiscountInfoModel {
Id = discount.Id,
CouponCode = couponCode
});
}
model.GiftVoucherBox.Display = _shoppingCartSettings.ShowGiftVoucherBox;
//cart warnings
var cartWarnings = await _shoppingCartValidator.GetShoppingCartWarnings(request.Cart, checkoutAttributes,
request.ValidateCheckoutAttributes, true);
foreach (var warning in cartWarnings)
model.Warnings.Add(warning);
#endregion
}
private async Task PrepareCheckoutAttributes(ShoppingCartModel model, GetShoppingCart request)
{
#region Checkout attributes
var checkoutAttributes =
await _checkoutAttributeService.GetAllCheckoutAttributes(request.Store.Id,
!request.Cart.RequiresShipping());
foreach (var attribute in checkoutAttributes)
{
var attributeModel = new ShoppingCartModel.CheckoutAttributeModel {
Id = attribute.Id,
Name = attribute.GetTranslation(x => x.Name, request.Language.Id),
TextPrompt = attribute.GetTranslation(x => x.TextPrompt, request.Language.Id),
IsRequired = attribute.IsRequired,
AttributeControlType = attribute.AttributeControlTypeId,
DefaultValue = attribute.DefaultValue
};
if (!string.IsNullOrEmpty(attribute.ValidationFileAllowedExtensions))
attributeModel.AllowedFileExtensions = attribute.ValidationFileAllowedExtensions
.Split([','], StringSplitOptions.RemoveEmptyEntries)
.ToList();
if (attribute.ShouldHaveValues())
{
//values
var attributeValues = attribute.CheckoutAttributeValues;
foreach (var attributeValue in attributeValues)
{
var attributeValueModel = new ShoppingCartModel.CheckoutAttributeValueModel {
Id = attributeValue.Id,
Name = attributeValue.GetTranslation(x => x.Name, request.Language.Id),
ColorSquaresRgb = attributeValue.ColorSquaresRgb,
IsPreSelected = attributeValue.IsPreSelected
};
attributeModel.Values.Add(attributeValueModel);
//display price if allowed
if (!await _permissionService.Authorize(StandardPermission.DisplayPrices)) continue;
var priceAdjustmentBase = (await _taxService.GetCheckoutAttributePrice(attribute, attributeValue))
.checkoutPrice;
var priceAdjustment =
await _currencyService.ConvertFromPrimaryStoreCurrency(priceAdjustmentBase, request.Currency);
switch (priceAdjustmentBase)
{
case > 0:
attributeValueModel.PriceAdjustment = "+" + _priceFormatter.FormatPrice(priceAdjustment);
break;
case < 0:
attributeValueModel.PriceAdjustment = "-" + _priceFormatter.FormatPrice(-priceAdjustment);
break;
}
}
}
//set already selected attributes
var selectedCheckoutAttributes =
request.Customer.GetUserFieldFromEntity<List<CustomAttribute>>(
SystemCustomerFieldNames.CheckoutAttributes, request.Store.Id);
switch (attribute.AttributeControlTypeId)
{
case AttributeControlType.DropdownList:
case AttributeControlType.RadioList:
case AttributeControlType.Checkboxes:
case AttributeControlType.ColorSquares:
case AttributeControlType.ImageSquares:
{
if (selectedCheckoutAttributes != null && selectedCheckoutAttributes.Any())
{
//clear default selection
foreach (var item in attributeModel.Values)
item.IsPreSelected = false;
//select new values
var selectedValues =
await _checkoutAttributeParser.ParseCheckoutAttributeValues(selectedCheckoutAttributes);
foreach (var attributeValue in selectedValues)
if (attributeModel.Id == attributeValue.CheckoutAttributeId)
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:
case AttributeControlType.Datepicker:
{
if (selectedCheckoutAttributes != null && selectedCheckoutAttributes.Any())
{
var enteredText = selectedCheckoutAttributes.Where(x => x.Key == attribute.Id)
.Select(x => x.Value).ToList();
if (enteredText.Any())
attributeModel.DefaultValue = enteredText[0];
}
}
break;
case AttributeControlType.FileUpload:
{
if (selectedCheckoutAttributes != null && selectedCheckoutAttributes.Any())
{
var downloadGuidStr = selectedCheckoutAttributes.Where(x => x.Key == attribute.Id)
.Select(x => x.Value).FirstOrDefault();
Guid.TryParse(downloadGuidStr, out var downloadGuid);
var download = await _downloadService.GetDownloadByGuid(downloadGuid);
if (download != null)
attributeModel.DefaultValue = download.DownloadGuid.ToString();
}
}
break;
}
model.CheckoutAttributes.Add(attributeModel);
}
#endregion
}
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 sename = product.GetSeName(request.Language.Id);
var cartItemModel = new ShoppingCartModel.ShoppingCartItemModel {
Id = sci.Id,
Sku = product.FormatSku(sci.Attributes),
IsCart = sci.ShoppingCartTypeId == ShoppingCartType.ShoppingCart,
ProductId = product.Id,
WarehouseId = sci.WarehouseId,
ProductName = product.GetTranslation(x => x.Name, request.Language.Id),
ProductSeName = sename,
ProductUrl = _linkGenerator.GetPathByRouteValues("Product", new { SeName = sename }),
Quantity = sci.Quantity,
AttributeInfo = await _productAttributeFormatter.FormatAttributes(product, sci.Attributes),
AllowItemEditing = _shoppingCartSettings.AllowCartItemEditing && product.VisibleIndividually
};
if (product.RequireOtherProducts)
cartItemModel.DisableRemoval = product.RequireOtherProducts && product.ParseRequiredProductIds()
.Intersect(request.Cart.Select(x => x.ProductId)).Any();
//warehouse
if (!string.IsNullOrEmpty(cartItemModel.WarehouseId))
{
var warehouse = await _warehouseService.GetWarehouseById(cartItemModel.WarehouseId);
cartItemModel.WarehouseName = warehouse?.Name;
cartItemModel.WarehouseCode = warehouse?.Code;
}
//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(
_translationService.GetResource("ShoppingCart.RecurringPeriod"),
product.RecurringCycleLength,
_enumTranslationService.GetTranslationEnum(product.RecurringCyclePeriodId),
product.RecurringTotalCycles);
//reservation info
if (product.ProductTypeId == ProductType.Reservation)
{
if (sci.RentalEndDateUtc == default(DateTime) || sci.RentalEndDateUtc == null)
cartItemModel.ReservationInfo =
string.Format(_translationService.GetResource("ShoppingCart.Reservation.StartDate"),
sci.RentalStartDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat));
else
cartItemModel.ReservationInfo = string.Format(
_translationService.GetResource("ShoppingCart.Reservation.Date"),
sci.RentalStartDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat),
sci.RentalEndDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat));
if (!string.IsNullOrEmpty(sci.Parameter))
{
cartItemModel.ReservationInfo += "<br>" +
string.Format(
_translationService.GetResource(
"ShoppingCart.Reservation.Option"), sci.Parameter);
cartItemModel.Parameter = sci.Parameter;
}
if (!string.IsNullOrEmpty(sci.Duration))
cartItemModel.ReservationInfo += "<br>" +
string.Format(
_translationService.GetResource(
"ShoppingCart.Reservation.Duration"), sci.Duration);
}
if (sci.ShoppingCartTypeId == ShoppingCartType.Auctions)
{
cartItemModel.DisableRemoval = true;
cartItemModel.AuctionInfo = _translationService.GetResource("ShoppingCart.auctionwonon") + " " +
_dateTimeService.ConvertToUserTime(product.AvailableEndDateTimeUtc.Value,
DateTimeKind.Utc);
}
//unit prices
if (product.CallForPrice)
{
cartItemModel.UnitPrice = _translationService.GetResource("Products.CallForPrice");
cartItemModel.SubTotal = _translationService.GetResource("Products.CallForPrice");
cartItemModel.UnitPriceWithoutDiscount = _translationService.GetResource("Products.CallForPrice");
}
else
{
var unitprices = await _pricingService.GetUnitPrice(sci, product);
var appliedDiscounts = unitprices.appliedDiscounts;
var productprices = await _taxService.GetProductPrice(product, unitprices.unitprice);
cartItemModel.UnitPriceWithoutDiscountValue =
(await _taxService.GetProductPrice(product,
(await _pricingService.GetUnitPrice(sci, product, false)).unitprice)).productprice;
cartItemModel.UnitPriceWithoutDiscount =
_priceFormatter.FormatPrice(cartItemModel.UnitPriceWithoutDiscountValue);
cartItemModel.UnitPriceValue = productprices.productprice;
cartItemModel.UnitPrice = _priceFormatter.FormatPrice(productprices.productprice);
if (appliedDiscounts.Any())
{
if (appliedDiscounts.Any(x => x.MaximumDiscountedQuantity.HasValue))
{
cartItemModel.DiscountedQty = appliedDiscounts.Where(x => x.MaximumDiscountedQuantity.HasValue).Max(x => x.MaximumDiscountedQuantity.Value);
}
appliedDiscounts.ForEach(x => cartItemModel.Discounts.Add(x.DiscountId));
}
//sub total
var subtotal = await _pricingService.GetSubTotal(sci, product);
var shoppingCartItemDiscountBase = subtotal.discountAmount;
var shoppingCartItemSubTotalWithDiscount =
(await _taxService.GetProductPrice(product, subtotal.subTotal)).productprice;
cartItemModel.SubTotal = _priceFormatter.FormatPrice(shoppingCartItemSubTotalWithDiscount);
cartItemModel.SubTotalValue = shoppingCartItemSubTotalWithDiscount;
//display an applied discount amount
if (shoppingCartItemDiscountBase > 0)
{
shoppingCartItemDiscountBase =
(await _taxService.GetProductPrice(product, shoppingCartItemDiscountBase)).productprice;
if (shoppingCartItemDiscountBase > 0)
cartItemModel.Discount = _priceFormatter.FormatPrice(shoppingCartItemDiscountBase);
}
}
//picture
if (_shoppingCartSettings.ShowProductImagesOnShoppingCart)
cartItemModel.Picture = await PrepareCartItemPicture(product, sci.Attributes);
//item warnings
var itemWarnings = await _shoppingCartValidator.GetShoppingCartItemWarnings(request.Customer, sci, product,
new ShoppingCartValidatorOptions());
foreach (var warning in itemWarnings)
cartItemModel.Warnings.Add(warning);
model.Items.Add(cartItemModel);
}
#endregion
}
private async Task<PictureModel> PrepareCartItemPicture(Product product, IList<CustomAttribute> attributes)
{
var sciPicture = await product.GetProductPicture(attributes, _productService, _pictureService);
return new PictureModel {
Id = sciPicture?.Id,
ImageUrl = await _pictureService.GetPictureUrl(sciPicture, _mediaSettings.CartThumbPictureSize),
Title = string.Format(_translationService.GetResource("Media.Product.ImageLinkTitleFormat"), product.Name),
AlternateText = string.Format(_translationService.GetResource("Media.Product.ImageAlternateTextFormat"),
product.Name)
};
}
}