public ActionResult List(GridCommand command)
{
var model = new GridModel <CheckoutAttributeModel>();
if (_services.Permissions.Authorize(StandardPermissionProvider.ManageCatalog))
{
var checkoutAttributes = _checkoutAttributeService.GetAllCheckoutAttributes(true);
model.Data = checkoutAttributes.Select(x =>
{
var caModel = x.ToModel();
caModel.AttributeControlTypeName = x.AttributeControlType.GetLocalizedEnum(_services.Localization, _services.WorkContext);
return(caModel);
});
model.Total = checkoutAttributes.Count();
}
else
{
model.Data = Enumerable.Empty <CheckoutAttributeModel>();
NotifyAccessDenied();
}
return(new JsonResult
{
Data = model
});
}
private void UpdateCheckoutAttribute(PostBackModel model)
{
var cart = _workContext.CurrentCustomer.ShoppingCartItems
.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart)
.LimitPerStore(_storeContext.CurrentStore.Id)
.ToList();
var collectPoint = string.Format(@"{0}, {1} {2}, {3} {4}, {5}",
model.CustomerPostalLocation, model.CustomerStreet, model.CustomerStreetNumber,
model.CustomerPostalCode, model.CustomerCity, model.CustomerCountry);
var checkoutAttributes = _checkoutAttributeService.GetAllCheckoutAttributes(_storeContext.CurrentStore.Id, !cart.RequiresShipping());
//var attributesXml = _workContext.CurrentCustomer.GetAttribute<string>(SystemCustomerAttributeNames.CheckoutAttributes, _storeContext.CurrentStore.Id);
var attributesXml = string.Empty;
foreach (var attribute in checkoutAttributes)
{
if (attribute.Name == "CollectPoint")
{
attributesXml = _checkoutAttributeParser.AddCheckoutAttribute(attributesXml, attribute, collectPoint);
}
if (attribute.Name == "OrderReference")
{
attributesXml = _checkoutAttributeParser.AddCheckoutAttribute(attributesXml, attribute, model.OrderReference);
}
}
_genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, SystemCustomerAttributeNames.CheckoutAttributes, attributesXml, _storeContext.CurrentStore.Id);
_genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, CustomCustomerAttributeNames.DeliveryMethod, model.DeliveryMethod, _storeContext.CurrentStore.Id);
_genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, CustomCustomerAttributeNames.DeliveryMethodRate, model.DeliveryMethodPriceTotalEuro, _storeContext.CurrentStore.Id);
_genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, CustomCustomerAttributeNames.DeliveryMethodAddress, collectPoint, _storeContext.CurrentStore.Id);
}
/// <summary>
/// Prepare condition attributes model
/// </summary>
/// <param name="model">Condition attributes model</param>
/// <param name="checkoutAttribute">Checkout attribute</param>
protected virtual void PrepareConditionAttributesModel(ConditionModel model, CheckoutAttribute checkoutAttribute)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (checkoutAttribute == null)
{
throw new ArgumentNullException(nameof(checkoutAttribute));
}
model.EnableCondition = !string.IsNullOrEmpty(checkoutAttribute.ConditionAttributeXml);
if (!model.EnableCondition)
{
return;
}
//get selected checkout attribute
var selectedAttribute = _checkoutAttributeParser.ParseCheckoutAttributes(checkoutAttribute.ConditionAttributeXml).FirstOrDefault();
model.SelectedAttributeId = selectedAttribute?.Id ?? 0;
//get selected checkout attribute values identifiers
var selectedValuesIds = _checkoutAttributeParser
.ParseCheckoutAttributeValues(checkoutAttribute.ConditionAttributeXml).Select(value => value.Id);
//get available condition checkout attributes (ignore this attribute and non-combinable attributes)
var availableConditionAttributes = _checkoutAttributeService.GetAllCheckoutAttributes()
.Where(attribute => attribute.Id != checkoutAttribute.Id && attribute.CanBeUsedAsCondition());
model.ConditionAttributes = availableConditionAttributes.Select(attribute => new AttributeConditionModel
{
Id = attribute.Id,
Name = attribute.Name,
AttributeControlType = attribute.AttributeControlType,
Values = _checkoutAttributeService.GetCheckoutAttributeValues(attribute.Id).Select(value => new SelectListItem
{
Text = value.Name,
Value = value.Id.ToString(),
Selected = selectedAttribute?.Id == attribute.Id && selectedValuesIds.Contains(value.Id)
}).ToList()
}).ToList();
}
public virtual async Task <IActionResult> CheckoutAttributeChange(IFormCollection form,
[FromServices] ICheckoutAttributeParser checkoutAttributeParser,
[FromServices] ICheckoutAttributeFormatter checkoutAttributeFormatter)
{
var cart = _shoppingCartService.GetShoppingCart(_storeContext.CurrentStore.Id, ShoppingCartType.ShoppingCart, ShoppingCartType.Auctions);
var attributeXml = await _mediator.Send(new SaveCheckoutAttributesCommand()
{
Customer = _workContext.CurrentCustomer,
Store = _storeContext.CurrentStore,
Cart = cart,
Form = form
});
var enabledAttributeIds = new List <string>();
var disabledAttributeIds = new List <string>();
var attributes = await _checkoutAttributeService.GetAllCheckoutAttributes(_storeContext.CurrentStore.Id, !cart.RequiresShipping());
foreach (var attribute in attributes)
{
var conditionMet = await checkoutAttributeParser.IsConditionMet(attribute, attributeXml);
if (conditionMet.HasValue)
{
if (conditionMet.Value)
{
enabledAttributeIds.Add(attribute.Id);
}
else
{
disabledAttributeIds.Add(attribute.Id);
}
}
}
var model = await _mediator.Send(new GetOrderTotals()
{
Cart = cart,
IsEditable = true,
Store = _storeContext.CurrentStore,
Currency = _workContext.WorkingCurrency,
Customer = _workContext.CurrentCustomer,
Language = _workContext.WorkingLanguage,
TaxDisplayType = _workContext.TaxDisplayType
});
return(Json(new
{
enabledattributeids = enabledAttributeIds.ToArray(),
disabledattributeids = disabledAttributeIds.ToArray(),
htmlordertotal = await RenderPartialViewToString("Components/OrderTotals/Default", model),
model = model,
checkoutattributeinfo = await checkoutAttributeFormatter.FormatAttributes(attributeXml, _workContext.CurrentCustomer),
}));
}
protected virtual void PrepareConditionAttributes(CheckoutAttributeModel model, CheckoutAttribute checkoutAttribute)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
//currenty any checkout attribute can have condition.
model.ConditionAllowed = true;
if (checkoutAttribute == null)
{
return;
}
var selectedAttribute = _checkoutAttributeParser.ParseCheckoutAttributes(checkoutAttribute.ConditionAttributeXml).FirstOrDefault();
var selectedValues = _checkoutAttributeParser.ParseCheckoutAttributeValues(checkoutAttribute.ConditionAttributeXml);
model.ConditionModel = new ConditionModel()
{
EnableCondition = !string.IsNullOrEmpty(checkoutAttribute.ConditionAttributeXml),
SelectedAttributeId = selectedAttribute != null ? selectedAttribute.Id : "",
ConditionAttributes = _checkoutAttributeService.GetAllCheckoutAttributes()
//ignore this attribute and non-combinable attributes
.Where(x => x.Id != checkoutAttribute.Id && x.CanBeUsedAsCondition())
.Select(x =>
new AttributeConditionModel()
{
Id = x.Id,
Name = x.Name,
AttributeControlType = x.AttributeControlType,
Values = x.CheckoutAttributeValues //_checkoutAttributeService.GetCheckoutAttributeValues(x.Id)
.Select(v => new SelectListItem()
{
Text = v.Name,
Value = v.Id.ToString(),
Selected = selectedAttribute != null && selectedAttribute.Id == x.Id && selectedValues.Any(sv => sv.Id == v.Id)
}).ToList()
}).ToList()
};
}
public virtual async Task PrepareConditionAttributes(CheckoutAttributeModel model, CheckoutAttribute checkoutAttribute)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
//currenty any checkout attribute can have condition.
model.ConditionAllowed = true;
if (checkoutAttribute == null)
{
return;
}
var selectedAttribute = (await _checkoutAttributeParser.ParseCheckoutAttributes(checkoutAttribute.ConditionAttribute)).FirstOrDefault();
var selectedValues = await _checkoutAttributeParser.ParseCheckoutAttributeValues(checkoutAttribute.ConditionAttribute);
model.ConditionModel = new ConditionModel()
{
EnableCondition = checkoutAttribute.ConditionAttribute.Any(),
SelectedAttributeId = selectedAttribute != null ? selectedAttribute.Id : "",
ConditionAttributes = (await _checkoutAttributeService.GetAllCheckoutAttributes(ignorAcl: false))
//ignore this attribute and non-combinable attributes
.Where(x => x.Id != checkoutAttribute.Id && x.CanBeUsedAsCondition())
.Select(x =>
new AttributeConditionModel()
{
Id = x.Id,
Name = x.Name,
AttributeControlType = x.AttributeControlTypeId,
Values = x.CheckoutAttributeValues
.Select(v => new SelectListItem()
{
Text = v.Name,
Value = v.Id.ToString(),
Selected = selectedAttribute != null && selectedAttribute.Id == x.Id && selectedValues.Any(sv => sv.Id == v.Id)
}).ToList()
}).ToList()
};
}
public ActionResult List()
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageCatalog))
{
return(AccessDeniedView());
}
var checkoutAttributes = _checkoutAttributeService.GetAllCheckoutAttributes(false);
var gridModel = new GridModel <CheckoutAttributeModel>
{
Data = checkoutAttributes.Select(x =>
{
var caModel = x.ToModel();
caModel.AttributeControlTypeName = x.AttributeControlType.GetLocalizedEnum(_localizationService, _workContext);
return(caModel);
}),
Total = checkoutAttributes.Count()
};
return(View(gridModel));
}
private string GetSelectedCheckoutAttributesThatHasNotBeenSentToKlarna(Customer customer, int currentStoreId)
{
string checkoutAttributesXml = null;
var originalCheckoutAttributesXml = customer.GetAttribute <string>(SystemCustomerAttributeNames.CheckoutAttributes, currentStoreId);
var allCheckoutAttributes = _checkoutAttributeService.GetAllCheckoutAttributes(currentStoreId);
foreach (var checkoutAttribute in allCheckoutAttributes.Where(x => !x.ShouldHaveValues()))
{
var selectedValues = _checkoutAttributeParser.ParseValues(originalCheckoutAttributesXml, checkoutAttribute.Id);
foreach (var selectedValue in selectedValues)
{
checkoutAttributesXml = _checkoutAttributeParser.AddCheckoutAttribute(checkoutAttributesXml, checkoutAttribute, selectedValue);
}
}
return(checkoutAttributesXml);
}
public virtual IActionResult CheckoutAttributeChange(IFormCollection form,
[FromServices] ICheckoutAttributeParser checkoutAttributeParser,
[FromServices] ICheckoutAttributeFormatter checkoutAttributeFormatter)
{
var cart = _workContext.CurrentCustomer.ShoppingCartItems
.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart || sci.ShoppingCartType == ShoppingCartType.Auctions)
.LimitPerStore(_storeContext.CurrentStore.Id)
.ToList();
_shoppingCartViewModelService.ParseAndSaveCheckoutAttributes(cart, form);
var attributeXml = _workContext.CurrentCustomer.GetAttribute <string>(SystemCustomerAttributeNames.CheckoutAttributes,
_storeContext.CurrentStore.Id);
var enabledAttributeIds = new List <string>();
var disabledAttributeIds = new List <string>();
var attributes = _checkoutAttributeService.GetAllCheckoutAttributes(_storeContext.CurrentStore.Id, !cart.RequiresShipping());
foreach (var attribute in attributes)
{
var conditionMet = checkoutAttributeParser.IsConditionMet(attribute, attributeXml);
if (conditionMet.HasValue)
{
if (conditionMet.Value)
{
enabledAttributeIds.Add(attribute.Id);
}
else
{
disabledAttributeIds.Add(attribute.Id);
}
}
}
return(Json(new
{
enabledattributeids = enabledAttributeIds.ToArray(),
disabledattributeids = disabledAttributeIds.ToArray(),
htmlordertotal = this.RenderPartialViewToString("Components/OrderTotals/Default", _shoppingCartViewModelService.PrepareOrderTotals(cart, true)),
checkoutattributeinfo = checkoutAttributeFormatter.FormatAttributes(attributeXml, _workContext.CurrentCustomer),
}));
}
public ActionResult List(DataSourceRequest command)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageAttributes))
{
return(AccessDeniedView());
}
var checkoutAttributes = _checkoutAttributeService.GetAllCheckoutAttributes();
var gridModel = new DataSourceResult
{
Data = checkoutAttributes.Select(x =>
{
var attributeModel = x.ToModel();
attributeModel.AttributeControlTypeName = x.AttributeControlType.GetLocalizedEnum(_localizationService, _workContext);
return(attributeModel);
}),
Total = checkoutAttributes.Count()
};
return(Json(gridModel));
}
public virtual async Task <IActionResult> CheckoutAttributeChange(IFormCollection form,
[FromServices] ICheckoutAttributeParser checkoutAttributeParser,
[FromServices] ICheckoutAttributeFormatter checkoutAttributeFormatter)
{
var cart = _shoppingCartService.GetShoppingCart(_storeContext.CurrentStore.Id, ShoppingCartType.ShoppingCart, ShoppingCartType.Auctions);
await _shoppingCartViewModelService.ParseAndSaveCheckoutAttributes(cart, form);
var attributeXml = await _workContext.CurrentCustomer.GetAttribute <string>(_genericAttributeService, SystemCustomerAttributeNames.CheckoutAttributes,
_storeContext.CurrentStore.Id);
var enabledAttributeIds = new List <string>();
var disabledAttributeIds = new List <string>();
var attributes = await _checkoutAttributeService.GetAllCheckoutAttributes(_storeContext.CurrentStore.Id, !cart.RequiresShipping());
foreach (var attribute in attributes)
{
var conditionMet = await checkoutAttributeParser.IsConditionMet(attribute, attributeXml);
if (conditionMet.HasValue)
{
if (conditionMet.Value)
{
enabledAttributeIds.Add(attribute.Id);
}
else
{
disabledAttributeIds.Add(attribute.Id);
}
}
}
return(Json(new
{
enabledattributeids = enabledAttributeIds.ToArray(),
disabledattributeids = disabledAttributeIds.ToArray(),
htmlordertotal = RenderPartialViewToString("Components/OrderTotals/Default", await _shoppingCartViewModelService.PrepareOrderTotals(cart, true)),
checkoutattributeinfo = await checkoutAttributeFormatter.FormatAttributes(attributeXml, _workContext.CurrentCustomer),
}));
}
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.GetLocalized(x => x.Name, request.Language.Id),
TextPrompt = attribute.GetLocalized(x => x.TextPrompt, request.Language.Id),
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 = attribute.CheckoutAttributeValues;
foreach (var attributeValue in attributeValues)
{
var attributeValueModel = new ShoppingCartModel.CheckoutAttributeValueModel {
Id = attributeValue.Id,
Name = attributeValue.GetLocalized(x => x.Name, request.Language.Id),
ColorSquaresRgb = attributeValue.ColorSquaresRgb,
IsPreSelected = attributeValue.IsPreSelected,
};
attributeModel.Values.Add(attributeValueModel);
//display price if allowed
if (await _permissionService.Authorize(StandardPermissionProvider.DisplayPrices))
{
decimal priceAdjustmentBase = (await _taxService.GetCheckoutAttributePrice(attribute, attributeValue)).checkoutPrice;
decimal priceAdjustment = await _currencyService.ConvertFromPrimaryStoreCurrency(priceAdjustmentBase, request.Currency);
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 = request.Customer.GetAttributeFromEntity <string>(SystemCustomerAttributeNames.CheckoutAttributes, request.Store.Id);
switch (attribute.AttributeControlType)
{
case AttributeControlType.DropdownList:
case AttributeControlType.RadioList:
case AttributeControlType.Checkboxes:
case AttributeControlType.ColorSquares:
case AttributeControlType.ImageSquares:
{
if (!String.IsNullOrEmpty(selectedCheckoutAttributes))
{
//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:
{
if (!String.IsNullOrEmpty(selectedCheckoutAttributes))
{
var enteredText = _checkoutAttributeParser.ParseValues(selectedCheckoutAttributes, attribute.Id);
if (enteredText.Any())
{
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.Any())
{
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;
case AttributeControlType.FileUpload:
{
if (!String.IsNullOrEmpty(selectedCheckoutAttributes))
{
var downloadGuidStr = _checkoutAttributeParser.ParseValues(selectedCheckoutAttributes, attribute.Id).FirstOrDefault();
Guid downloadGuid;
Guid.TryParse(downloadGuidStr, out downloadGuid);
var download = await _downloadService.GetDownloadByGuid(downloadGuid);
if (download != null)
{
attributeModel.DefaultValue = download.DownloadGuid.ToString();
}
}
}
break;
default:
break;
}
model.CheckoutAttributes.Add(attributeModel);
}
#endregion
}
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);
}
/// <summary>
/// Validates whether this shopping cart is valid
/// </summary>
/// <param name="shoppingCart">Shopping cart</param>
/// <param name="checkoutAttributes">Checkout attributes</param>
/// <param name="validateCheckoutAttributes">A value indicating whether to validate checkout attributes</param>
/// <returns>Warnings</returns>
public virtual IList <string> GetShoppingCartWarnings(IList <ShoppingCartItem> shoppingCart,
string checkoutAttributes, bool validateCheckoutAttributes)
{
var warnings = new List <string>();
bool hasStandartProducts = false;
bool hasRecurringProducts = false;
foreach (var sci in shoppingCart)
{
var productVariant = sci.ProductVariant;
if (productVariant == null)
{
warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.CannotLoadProductVariant"), sci.ProductVariantId));
return(warnings);
}
if (productVariant.IsRecurring)
{
hasRecurringProducts = true;
}
else
{
hasStandartProducts = true;
}
}
//don't mix standard and recurring products
if (hasStandartProducts && hasRecurringProducts)
{
warnings.Add(_localizationService.GetResource("ShoppingCart.CannotMixStandardAndAutoshipProducts"));
}
//recurring cart validation
if (hasRecurringProducts)
{
int cycleLength = 0;
RecurringProductCyclePeriod cyclePeriod = RecurringProductCyclePeriod.Days;
int totalCycles = 0;
string cyclesError = shoppingCart.GetRecurringCycleInfo(out cycleLength, out cyclePeriod, out totalCycles);
if (!string.IsNullOrEmpty(cyclesError))
{
warnings.Add(cyclesError);
return(warnings);
}
}
//validate checkout attributes
if (validateCheckoutAttributes)
{
//selected attributes
var ca1Collection = _checkoutAttributeParser.ParseCheckoutAttributes(checkoutAttributes);
//existing checkout attributes
var ca2Collection = _checkoutAttributeService.GetAllCheckoutAttributes();
if (!shoppingCart.RequiresShipping())
{
//remove attributes which require shippable products
ca2Collection = ca2Collection.RemoveShippableAttributes();
}
foreach (var ca2 in ca2Collection)
{
if (ca2.IsRequired)
{
bool found = false;
//selected checkout attributes
foreach (var ca1 in ca1Collection)
{
if (ca1.Id == ca2.Id)
{
var caValuesStr = _checkoutAttributeParser.ParseValues(checkoutAttributes, ca1.Id);
foreach (string str1 in caValuesStr)
{
if (!String.IsNullOrEmpty(str1.Trim()))
{
found = true;
break;
}
}
}
}
//if not found
if (!found)
{
if (!string.IsNullOrEmpty(ca2.GetLocalized(a => a.TextPrompt)))
{
warnings.Add(ca2.GetLocalized(a => a.TextPrompt));
}
else
{
warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.SelectAttribute"), ca2.GetLocalized(a => a.Name)));
}
}
}
}
}
return(warnings);
}
public virtual async Task <IList <string> > GetShoppingCartWarnings(IList <ShoppingCartItem> shoppingCart,
IList <CustomAttribute> checkoutAttributes, bool validateCheckoutAttributes)
{
var warnings = new List <string>();
if (checkoutAttributes == null)
{
checkoutAttributes = new List <CustomAttribute>();
}
bool hasStandartProducts = false;
bool hasRecurringProducts = false;
foreach (var sci in shoppingCart)
{
var product = await _productService.GetProductById(sci.ProductId);
if (product == null)
{
warnings.Add(string.Format(_translationService.GetResource("ShoppingCart.CannotLoadProduct"), sci.ProductId));
return(warnings);
}
if (product.IsRecurring)
{
hasRecurringProducts = true;
}
else
{
hasStandartProducts = true;
}
}
//don't mix standard and recurring products
if (hasStandartProducts && hasRecurringProducts)
{
warnings.Add(_translationService.GetResource("ShoppingCart.CannotMixStandardAndAutoshipProducts"));
}
//validate checkout attributes
if (validateCheckoutAttributes)
{
//selected attributes
var attributes1 = await _checkoutAttributeParser.ParseCheckoutAttributes(checkoutAttributes);
//existing checkout attributes
var attributes2 = await _checkoutAttributeService.GetAllCheckoutAttributes(_workContext.CurrentStore.Id, !shoppingCart.RequiresShipping());
foreach (var a2 in attributes2)
{
var conditionMet = await _checkoutAttributeParser.IsConditionMet(a2, checkoutAttributes);
if (a2.IsRequired && ((conditionMet.HasValue && conditionMet.Value) || !conditionMet.HasValue))
{
bool found = false;
//selected checkout attributes
foreach (var a1 in attributes1)
{
if (a1.Id == a2.Id)
{
var attributeValuesStr = checkoutAttributes.Where(x => x.Key == a1.Id).Select(x => x.Value);
foreach (var str1 in attributeValuesStr)
{
if (!string.IsNullOrEmpty(str1.Trim()))
{
found = true;
break;
}
}
}
}
//if not found
if (!found)
{
if (!string.IsNullOrEmpty(a2.GetTranslation(a => a.TextPrompt, _workContext.WorkingLanguage.Id)))
{
warnings.Add(a2.GetTranslation(a => a.TextPrompt, _workContext.WorkingLanguage.Id));
}
else
{
warnings.Add(string.Format(_translationService.GetResource("ShoppingCart.SelectAttribute"), a2.GetTranslation(a => a.Name, _workContext.WorkingLanguage.Id)));
}
}
}
}
//now validation rules
//minimum length
foreach (var ca in attributes2)
{
if (ca.ValidationMinLength.HasValue)
{
if (ca.AttributeControlTypeId == AttributeControlType.TextBox ||
ca.AttributeControlTypeId == AttributeControlType.MultilineTextbox)
{
var valuesStr = checkoutAttributes.Where(x => x.Key == ca.Id).Select(x => x.Value);
var enteredText = valuesStr?.FirstOrDefault();
int enteredTextLength = string.IsNullOrEmpty(enteredText) ? 0 : enteredText.Length;
if (ca.ValidationMinLength.Value > enteredTextLength)
{
warnings.Add(string.Format(_translationService.GetResource("ShoppingCart.TextboxMinimumLength"), ca.GetTranslation(a => a.Name, _workContext.WorkingLanguage.Id), ca.ValidationMinLength.Value));
}
}
}
//maximum length
if (ca.ValidationMaxLength.HasValue)
{
if (ca.AttributeControlTypeId == AttributeControlType.TextBox ||
ca.AttributeControlTypeId == AttributeControlType.MultilineTextbox)
{
var valuesStr = checkoutAttributes.Where(x => x.Key == ca.Id).Select(x => x.Value);
var enteredText = valuesStr?.FirstOrDefault();
int enteredTextLength = string.IsNullOrEmpty(enteredText) ? 0 : enteredText.Length;
if (ca.ValidationMaxLength.Value < enteredTextLength)
{
warnings.Add(string.Format(_translationService.GetResource("ShoppingCart.TextboxMaximumLength"), ca.GetTranslation(a => a.Name, _workContext.WorkingLanguage.Id), ca.ValidationMaxLength.Value));
}
}
}
}
}
//event notification
await _mediator.ShoppingCartWarningsAdd(warnings, shoppingCart, checkoutAttributes, validateCheckoutAttributes);
return(warnings);
}
public async Task <IList <CustomAttribute> > Handle(SaveCheckoutAttributesCommand request, CancellationToken cancellationToken)
{
if (request.Cart == null)
{
throw new ArgumentNullException("cart");
}
if (request.Form == null)
{
throw new ArgumentNullException("form");
}
var customAttributes = new List <CustomAttribute>();
var checkoutAttributes = await _checkoutAttributeService.GetAllCheckoutAttributes(request.Store.Id, !request.Cart.RequiresShipping());
foreach (var attribute in checkoutAttributes)
{
string controlId = string.Format("checkout_attribute_{0}", attribute.Id);
switch (attribute.AttributeControlType)
{
case AttributeControlType.DropdownList:
case AttributeControlType.RadioList:
case AttributeControlType.ColorSquares:
case AttributeControlType.ImageSquares:
{
var ctrlAttributes = request.Form[controlId];
if (!string.IsNullOrEmpty(ctrlAttributes))
{
customAttributes = _checkoutAttributeParser.AddCheckoutAttribute(customAttributes,
attribute, ctrlAttributes).ToList();
}
}
break;
case AttributeControlType.Checkboxes:
{
var cblAttributes = request.Form[controlId].ToString();
if (!string.IsNullOrEmpty(cblAttributes))
{
foreach (var item in cblAttributes.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
customAttributes = _checkoutAttributeParser.AddCheckoutAttribute(customAttributes, attribute, item).ToList();
}
}
}
break;
case AttributeControlType.ReadonlyCheckboxes:
{
//load read-only (already server-side selected) values
var attributeValues = attribute.CheckoutAttributeValues;
foreach (var selectedAttributeId in attributeValues
.Where(v => v.IsPreSelected)
.Select(v => v.Id)
.ToList())
{
customAttributes = _checkoutAttributeParser.AddCheckoutAttribute(customAttributes,
attribute, selectedAttributeId.ToString()).ToList();
}
}
break;
case AttributeControlType.TextBox:
case AttributeControlType.MultilineTextbox:
{
var ctrlAttributes = request.Form[controlId].ToString();
if (!string.IsNullOrEmpty(ctrlAttributes))
{
string enteredText = ctrlAttributes.Trim();
customAttributes = _checkoutAttributeParser.AddCheckoutAttribute(customAttributes,
attribute, enteredText).ToList();
}
}
break;
case AttributeControlType.Datepicker:
{
var date = request.Form[controlId + "_day"];
var month = request.Form[controlId + "_month"];
var year = request.Form[controlId + "_year"];
DateTime?selectedDate = null;
try
{
selectedDate = new DateTime(Int32.Parse(year), Int32.Parse(month), Int32.Parse(date));
}
catch { }
if (selectedDate.HasValue)
{
customAttributes = _checkoutAttributeParser.AddCheckoutAttribute(customAttributes,
attribute, selectedDate.Value.ToString("D")).ToList();
}
}
break;
case AttributeControlType.FileUpload:
{
Guid downloadGuid;
Guid.TryParse(request.Form[controlId], out downloadGuid);
var download = await _downloadService.GetDownloadByGuid(downloadGuid);
if (download != null)
{
customAttributes = _checkoutAttributeParser.AddCheckoutAttribute(customAttributes,
attribute, download.DownloadGuid.ToString()).ToList();
}
}
break;
default:
break;
}
}
//save checkout attributes
//validate conditional attributes (if specified)
foreach (var attribute in checkoutAttributes)
{
var conditionMet = await _checkoutAttributeParser.IsConditionMet(attribute, customAttributes);
if (conditionMet.HasValue && !conditionMet.Value)
{
customAttributes = _checkoutAttributeParser.RemoveCheckoutAttribute(customAttributes, attribute).ToList();
}
}
await _genericAttributeService.SaveAttribute(request.Customer, SystemCustomerAttributeNames.CheckoutAttributes, customAttributes, request.Store.Id);
return(customAttributes);
}
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 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
}
