/// <summary>
/// Prepare paged bestseller list model
/// </summary>
/// <param name="searchModel">Bestseller search model</param>
/// <returns>Bestseller list model</returns>
public virtual async Task <BestsellerListModel> PrepareBestsellerListModelAsync(BestsellerSearchModel searchModel)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
var bestsellers = await GetBestsellersReportAsync(searchModel);
//prepare list model
var model = await new BestsellerListModel().PrepareToGridAsync(searchModel, bestsellers, () =>
{
return(bestsellers.SelectAwait(async bestseller =>
{
//fill in model values from the entity
var bestsellerModel = new BestsellerModel
{
ProductId = bestseller.ProductId,
TotalQuantity = bestseller.TotalQuantity
};
//fill in additional values (not existing in the entity)
bestsellerModel.ProductName = (await _productService.GetProductByIdAsync(bestseller.ProductId))?.Name;
bestsellerModel.TotalAmount = await _priceFormatter.FormatPriceAsync(bestseller.TotalAmount, true, false);
return bestsellerModel;
}));
});
return(model);
}
/// <summary>
/// Prepare paged shopping cart item list model
/// </summary>
/// <param name="searchModel">Shopping cart item search model</param>
/// <param name="customer">Customer</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the shopping cart item list model
/// </returns>
public virtual async Task <ShoppingCartItemListModel> PrepareShoppingCartItemListModelAsync(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 = (await _shoppingCartService.GetShoppingCartAsync(customer, searchModel.ShoppingCartType,
searchModel.StoreId, searchModel.ProductId, searchModel.StartDate, searchModel.EndDate)).ToPagedList(searchModel);
var isSearchProduct = searchModel.ProductId > 0;
Product product = null;
if (isSearchProduct)
{
product = await _productService.GetProductByIdAsync(searchModel.ProductId) ?? throw new Exception("Product is not found");
}
//prepare list model
var model = await new ShoppingCartItemListModel().PrepareToGridAsync(searchModel, items, () =>
{
return(items
.OrderByDescending(item => item.CreatedOnUtc)
.SelectAwait(async item =>
{
//fill in model values from the entity
var itemModel = item.ToModel <ShoppingCartItemModel>();
if (!isSearchProduct)
{
product = await _productService.GetProductByIdAsync(item.ProductId);
}
//convert dates to the user time
itemModel.UpdatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(item.UpdatedOnUtc, DateTimeKind.Utc);
//fill in additional values (not existing in the entity)
itemModel.Store = (await _storeService.GetStoreByIdAsync(item.StoreId))?.Name ?? "Deleted";
itemModel.AttributeInfo = await _productAttributeFormatter.FormatAttributesAsync(product, item.AttributesXml, customer);
var(unitPrice, _, _) = await _shoppingCartService.GetUnitPriceAsync(item, true);
itemModel.UnitPrice = await _priceFormatter.FormatPriceAsync((await _taxService.GetProductPriceAsync(product, unitPrice)).price);
var(subTotal, _, _, _) = await _shoppingCartService.GetSubTotalAsync(item, true);
itemModel.Total = await _priceFormatter.FormatPriceAsync((await _taxService.GetProductPriceAsync(product, subTotal)).price);
//set product name since it does not survive mapping
itemModel.ProductName = product.Name;
return itemModel;
}));
});
return(model);
}
public async Task CanFormatPriceWithCustomCurrencyFormatting()
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
var formatPrice = await _priceFormatter.FormatPriceAsync(1234.5M, false, _euro, _enLangId, false, false);
formatPrice.Should().Be("€1234.50");
}
/// <summary>
/// Prepares the order item models for return request by specified order.
/// </summary>
/// <param name="order">Order</param>
/// <returns>
/// The <see cref="Task"/> containing the <see cref="IList{SubmitReturnRequestModel.OrderItemModel}"/>
/// </returns>
protected virtual async Task <IList <SubmitReturnRequestModel.OrderItemModel> > PrepareSubmitReturnRequestOrderItemModelsAsync(Order order)
{
if (order is null)
{
throw new ArgumentNullException(nameof(order));
}
var models = new List <SubmitReturnRequestModel.OrderItemModel>();
var returnRequestAvailability = await _returnRequestService.GetReturnRequestAvailabilityAsync(order.Id);
if (returnRequestAvailability?.IsAllowed == true)
{
foreach (var returnableOrderItem in returnRequestAvailability.ReturnableOrderItems)
{
if (returnableOrderItem.AvailableQuantityForReturn == 0)
{
continue;
}
var orderItem = returnableOrderItem.OrderItem;
var product = await _productService.GetProductByIdAsync(orderItem.ProductId);
var model = new SubmitReturnRequestModel.OrderItemModel
{
Id = orderItem.Id,
ProductId = product.Id,
ProductName = await _localizationService.GetLocalizedAsync(product, x => x.Name),
ProductSeName = await _urlRecordService.GetSeNameAsync(product),
AttributeInfo = orderItem.AttributeDescription,
Quantity = returnableOrderItem.AvailableQuantityForReturn
};
var languageId = (await _workContext.GetWorkingLanguageAsync()).Id;
//unit price
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
model.UnitPrice = await _priceFormatter.FormatPriceAsync(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
model.UnitPrice = await _priceFormatter.FormatPriceAsync(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
}
models.Add(model);
}
}
return(models);
}
public virtual async Task <IActionResult> Edit(GiftCardModel model, bool continueEditing)
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageGiftCards))
{
return(AccessDeniedView());
}
//try to get a gift card with the specified id
var giftCard = await _giftCardService.GetGiftCardByIdAsync(model.Id);
if (giftCard == null)
{
return(RedirectToAction("List"));
}
var order = await _orderService.GetOrderByOrderItemAsync(giftCard.PurchasedWithOrderItemId ?? 0);
model.PurchasedWithOrderId = order?.Id;
model.RemainingAmountStr = await _priceFormatter.FormatPriceAsync(await _giftCardService.GetGiftCardRemainingAmountAsync(giftCard), true, false);
model.AmountStr = await _priceFormatter.FormatPriceAsync(giftCard.Amount, true, false);
model.CreatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(giftCard.CreatedOnUtc, DateTimeKind.Utc);
model.PrimaryStoreCurrencyCode = (await _currencyService.GetCurrencyByIdAsync(_currencySettings.PrimaryStoreCurrencyId)).CurrencyCode;
model.PurchasedWithOrderNumber = order?.CustomOrderNumber;
if (ModelState.IsValid)
{
giftCard = model.ToEntity(giftCard);
await _giftCardService.UpdateGiftCardAsync(giftCard);
//activity log
await _customerActivityService.InsertActivityAsync("EditGiftCard",
string.Format(await _localizationService.GetResourceAsync("ActivityLog.EditGiftCard"), giftCard.GiftCardCouponCode), giftCard);
_notificationService.SuccessNotification(await _localizationService.GetResourceAsync("Admin.GiftCards.Updated"));
if (!continueEditing)
{
return(RedirectToAction("List"));
}
return(RedirectToAction("Edit", new { id = giftCard.Id }));
}
//prepare model
model = await _giftCardModelFactory.PrepareGiftCardModelAsync(model, giftCard, true);
//if we got this far, something failed, redisplay form
return(View(model));
}
protected virtual async Task <CustomCheckoutConfirmModel> PrepareConfirmOrderModelAsync(IList <ShoppingCartItem> cart)
{
var model = new CustomCheckoutConfirmModel
{
TermsOfServiceOnOrderConfirmPage = _orderSettings.TermsOfServiceOnOrderConfirmPage
};
//min order amount validation
bool minOrderTotalAmountOk = await _orderProcessingService.ValidateMinOrderTotalAmountAsync(cart);
if (!minOrderTotalAmountOk)
{
decimal minOrderTotalAmount = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(
_orderSettings.MinOrderTotalAmount, await _workContext.GetWorkingCurrencyAsync()
);
model.MinOrderTotalWarning = string.Format(
await _localizationService.GetResourceAsync("Checkout.MinOrderTotalAmount"),
await _priceFormatter.FormatPriceAsync(minOrderTotalAmount, true, false)
);
}
model.SynchronyAuthTokenResponse = GetSynchronyAuthTokenResponse();
return(model);
}
/// <summary>
/// Prepare paged affiliated order list model
/// </summary>
/// <param name="searchModel">Affiliated order search model</param>
/// <param name="affiliate">Affiliate</param>
/// <returns>Affiliated order list model</returns>
public virtual async Task <AffiliatedOrderListModel> PrepareAffiliatedOrderListModelAsync(AffiliatedOrderSearchModel searchModel, Affiliate affiliate)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
if (affiliate == null)
{
throw new ArgumentNullException(nameof(affiliate));
}
//get parameters to filter orders
var startDateValue = !searchModel.StartDate.HasValue ? null
: (DateTime?)_dateTimeHelper.ConvertToUtcTime(searchModel.StartDate.Value, await _dateTimeHelper.GetCurrentTimeZoneAsync());
var endDateValue = !searchModel.EndDate.HasValue ? null
: (DateTime?)_dateTimeHelper.ConvertToUtcTime(searchModel.EndDate.Value, await _dateTimeHelper.GetCurrentTimeZoneAsync()).AddDays(1);
var orderStatusIds = searchModel.OrderStatusId > 0 ? new List <int> {
searchModel.OrderStatusId
} : null;
var paymentStatusIds = searchModel.PaymentStatusId > 0 ? new List <int> {
searchModel.PaymentStatusId
} : null;
var shippingStatusIds = searchModel.ShippingStatusId > 0 ? new List <int> {
searchModel.ShippingStatusId
} : null;
//get orders
var orders = await _orderService.SearchOrdersAsync(createdFromUtc : startDateValue,
createdToUtc : endDateValue,
osIds : orderStatusIds,
psIds : paymentStatusIds,
ssIds : shippingStatusIds,
affiliateId : affiliate.Id,
pageIndex : searchModel.Page - 1, pageSize : searchModel.PageSize);
//prepare list model
var model = await new AffiliatedOrderListModel().PrepareToGridAsync(searchModel, orders, () =>
{
//fill in model values from the entity
return(orders.SelectAwait(async order =>
{
var affiliatedOrderModel = order.ToModel <AffiliatedOrderModel>();
//fill in additional values (not existing in the entity)
affiliatedOrderModel.OrderStatus = await _localizationService.GetLocalizedEnumAsync(order.OrderStatus);
affiliatedOrderModel.PaymentStatus = await _localizationService.GetLocalizedEnumAsync(order.PaymentStatus);
affiliatedOrderModel.ShippingStatus = await _localizationService.GetLocalizedEnumAsync(order.ShippingStatus);
affiliatedOrderModel.OrderTotal = await _priceFormatter.FormatPriceAsync(order.OrderTotal, true, false);
affiliatedOrderModel.CreatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(order.CreatedOnUtc, DateTimeKind.Utc);
return affiliatedOrderModel;
}));
});
return(model);
}
PrepareProductOverviewPriceModelAsync(
Product product,
bool forceRedirectionAfterAddingToCart = false
)
{
var model = await base.PrepareProductOverviewPriceModelAsync(product, forceRedirectionAfterAddingToCart);
var newPrice = await _abcMattressListingPriceService.GetListingPriceForMattressProductAsync(
product.Id
);
if (newPrice != null)
{
model.Price = (await _priceFormatter.FormatPriceAsync(newPrice.Value)).Replace(".00", "");
}
return(model);
}
/// <summary>
/// Prepare the order item model
/// </summary>
/// <param name="orderItem">Order item</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the order item model
/// </returns>
public virtual async Task <SubmitReturnRequestModel.OrderItemModel> PrepareSubmitReturnRequestOrderItemModelAsync(OrderItem orderItem)
{
if (orderItem == null)
{
throw new ArgumentNullException(nameof(orderItem));
}
var order = await _orderService.GetOrderByIdAsync(orderItem.OrderId);
var product = await _productService.GetProductByIdAsync(orderItem.ProductId);
var model = new SubmitReturnRequestModel.OrderItemModel
{
Id = orderItem.Id,
ProductId = product.Id,
ProductName = await _localizationService.GetLocalizedAsync(product, x => x.Name),
ProductSeName = await _urlRecordService.GetSeNameAsync(product),
AttributeInfo = orderItem.AttributeDescription,
Quantity = orderItem.Quantity
};
var languageId = (await _workContext.GetWorkingLanguageAsync()).Id;
//unit price
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
model.UnitPrice = await _priceFormatter.FormatPriceAsync(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
model.UnitPrice = await _priceFormatter.FormatPriceAsync(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
}
return(model);
}
/// <summary>
/// Prepare paged gift card list model
/// </summary>
/// <param name="searchModel">Gift card search model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the gift card list model
/// </returns>
public virtual async Task <GiftCardListModel> PrepareGiftCardListModelAsync(GiftCardSearchModel searchModel)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
//get parameters to filter gift cards
var isActivatedOnly = searchModel.ActivatedId == 0 ? null : searchModel.ActivatedId == 1 ? true : (bool?)false;
//get gift cards
var giftCards = await _giftCardService.GetAllGiftCardsAsync(isGiftCardActivated : isActivatedOnly,
giftCardCouponCode : searchModel.CouponCode,
recipientName : searchModel.RecipientName,
pageIndex : searchModel.Page - 1, pageSize : searchModel.PageSize);
//prepare list model
var model = await new GiftCardListModel().PrepareToGridAsync(searchModel, giftCards, () =>
{
return(giftCards.SelectAwait(async giftCard =>
{
//fill in model values from the entity
var giftCardModel = giftCard.ToModel <GiftCardModel>();
//convert dates to the user time
giftCardModel.CreatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(giftCard.CreatedOnUtc, DateTimeKind.Utc);
//fill in additional values (not existing in the entity)
var giftAmount = await _giftCardService.GetGiftCardRemainingAmountAsync(giftCard);
giftCardModel.RemainingAmountStr = await _priceFormatter.FormatPriceAsync(giftAmount, true, false);
giftCardModel.AmountStr = await _priceFormatter.FormatPriceAsync(giftCard.Amount, true, false);
return giftCardModel;
}));
});
return(model);
}
/// <summary>
/// Prepare paged discount usage history list model
/// </summary>
/// <param name="searchModel">Discount usage history search model</param>
/// <param name="discount">Discount</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the discount usage history list model
/// </returns>
public virtual async Task <DiscountUsageHistoryListModel> PrepareDiscountUsageHistoryListModelAsync(DiscountUsageHistorySearchModel searchModel,
Discount discount)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
if (discount == null)
{
throw new ArgumentNullException(nameof(discount));
}
//get discount usage history
var history = await _discountService.GetAllDiscountUsageHistoryAsync(discountId : discount.Id,
pageIndex : searchModel.Page - 1, pageSize : searchModel.PageSize);
//prepare list model
var model = await new DiscountUsageHistoryListModel().PrepareToGridAsync(searchModel, history, () =>
{
return(history.SelectAwait(async historyEntry =>
{
//fill in model values from the entity
var discountUsageHistoryModel = historyEntry.ToModel <DiscountUsageHistoryModel>();
//convert dates to the user time
discountUsageHistoryModel.CreatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(historyEntry.CreatedOnUtc, DateTimeKind.Utc);
//fill in additional values (not existing in the entity)
var order = await _orderService.GetOrderByIdAsync(historyEntry.OrderId);
if (order != null)
{
discountUsageHistoryModel.OrderTotal = await _priceFormatter.FormatPriceAsync(order.OrderTotal, true, false);
discountUsageHistoryModel.CustomOrderNumber = order.CustomOrderNumber;
}
return discountUsageHistoryModel;
}));
});
return(model);
}
/// <summary>
/// Prepare the customer order list model
/// </summary>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the customer order list model
/// </returns>
public virtual async Task <CustomerOrderListModel> PrepareCustomerOrderListModelAsync()
{
var model = new CustomerOrderListModel();
var customer = await _workContext.GetCurrentCustomerAsync();
var store = await _storeContext.GetCurrentStoreAsync();
var orders = await _orderService.SearchOrdersAsync(storeId : store.Id,
customerId : customer.Id);
foreach (var order in orders)
{
var orderModel = new CustomerOrderListModel.OrderDetailsModel
{
Id = order.Id,
CreatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(order.CreatedOnUtc, DateTimeKind.Utc),
OrderStatusEnum = order.OrderStatus,
OrderStatus = await _localizationService.GetLocalizedEnumAsync(order.OrderStatus),
PaymentStatus = await _localizationService.GetLocalizedEnumAsync(order.PaymentStatus),
ShippingStatus = await _localizationService.GetLocalizedEnumAsync(order.ShippingStatus),
IsReturnRequestAllowed = await _orderProcessingService.IsReturnRequestAllowedAsync(order),
CustomOrderNumber = order.CustomOrderNumber
};
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
orderModel.OrderTotal = await _priceFormatter.FormatPriceAsync(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, (await _workContext.GetWorkingLanguageAsync()).Id);
model.Orders.Add(orderModel);
}
var recurringPayments = await _orderService.SearchRecurringPaymentsAsync(store.Id,
customer.Id);
foreach (var recurringPayment in recurringPayments)
{
var order = await _orderService.GetOrderByIdAsync(recurringPayment.InitialOrderId);
var recurringPaymentModel = new CustomerOrderListModel.RecurringOrderModel
{
Id = recurringPayment.Id,
StartDate = (await _dateTimeHelper.ConvertToUserTimeAsync(recurringPayment.StartDateUtc, DateTimeKind.Utc)).ToString(),
CycleInfo = $"{recurringPayment.CycleLength} {await _localizationService.GetLocalizedEnumAsync(recurringPayment.CyclePeriod)}",
NextPayment = await _orderProcessingService.GetNextPaymentDateAsync(recurringPayment) is DateTime nextPaymentDate ? (await _dateTimeHelper.ConvertToUserTimeAsync(nextPaymentDate, DateTimeKind.Utc)).ToString() : "",
TotalCycles = recurringPayment.TotalCycles,
CyclesRemaining = await _orderProcessingService.GetCyclesRemainingAsync(recurringPayment),
InitialOrderId = order.Id,
InitialOrderNumber = order.CustomOrderNumber,
CanCancel = await _orderProcessingService.CanCancelRecurringPaymentAsync(customer, recurringPayment),
CanRetryLastPayment = await _orderProcessingService.CanRetryLastRecurringPaymentAsync(customer, recurringPayment)
};
model.RecurringOrders.Add(recurringPaymentModel);
}
return(model);
}
/// <summary>
/// Formats attributes
/// </summary>
/// <param name="product">Product</param>
/// <param name="attributesXml">Attributes in XML format</param>
/// <param name="customer">Customer</param>
/// <param name="separator">Separator</param>
/// <param name="htmlEncode">A value indicating whether to encode (HTML) values</param>
/// <param name="renderPrices">A value indicating whether to render prices</param>
/// <param name="renderProductAttributes">A value indicating whether to render product attributes</param>
/// <param name="renderGiftCardAttributes">A value indicating whether to render gift card attributes</param>
/// <param name="allowHyperlinks">A value indicating whether to HTML hyperink tags could be rendered (if required)</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the attributes
/// </returns>
public virtual async Task <string> FormatAttributesAsync(Product product, string attributesXml,
Customer customer, string separator = "<br />", bool htmlEncode = true, bool renderPrices = true,
bool renderProductAttributes = true, bool renderGiftCardAttributes = true,
bool allowHyperlinks = true)
{
var result = new StringBuilder();
//attributes
if (renderProductAttributes)
{
foreach (var attribute in await _productAttributeParser.ParseProductAttributeMappingsAsync(attributesXml))
{
var productAttribute = await _productAttributeService.GetProductAttributeByIdAsync(attribute.ProductAttributeId);
var attributeName = await _localizationService.GetLocalizedAsync(productAttribute, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id);
//attributes without values
if (!attribute.ShouldHaveValues())
{
foreach (var value in _productAttributeParser.ParseValues(attributesXml, attribute.Id))
{
var formattedAttribute = string.Empty;
if (attribute.AttributeControlType == AttributeControlType.MultilineTextbox)
{
//encode (if required)
if (htmlEncode)
{
attributeName = WebUtility.HtmlEncode(attributeName);
}
//we never encode multiline textbox input
formattedAttribute = $"{attributeName}: {HtmlHelper.FormatText(value, false, true, false, false, false, false)}";
}
else if (attribute.AttributeControlType == AttributeControlType.FileUpload)
{
//file upload
Guid.TryParse(value, out var downloadGuid);
var download = await _downloadService.GetDownloadByGuidAsync(downloadGuid);
if (download != null)
{
var fileName = $"{download.Filename ?? download.DownloadGuid.ToString()}{download.Extension}";
//encode (if required)
if (htmlEncode)
{
fileName = WebUtility.HtmlEncode(fileName);
}
var attributeText = allowHyperlinks ? $"<a href=\"{_webHelper.GetStoreLocation(false)}download/getfileupload/?downloadId={download.DownloadGuid}\" class=\"fileuploadattribute\">{fileName}</a>"
: fileName;
//encode (if required)
if (htmlEncode)
{
attributeName = WebUtility.HtmlEncode(attributeName);
}
formattedAttribute = $"{attributeName}: {attributeText}";
}
}
else
{
//other attributes (textbox, datepicker)
formattedAttribute = $"{attributeName}: {value}";
//encode (if required)
if (htmlEncode)
{
formattedAttribute = WebUtility.HtmlEncode(formattedAttribute);
}
}
if (string.IsNullOrEmpty(formattedAttribute))
{
continue;
}
if (result.Length > 0)
{
result.Append(separator);
}
result.Append(formattedAttribute);
}
}
//product attribute values
else
{
foreach (var attributeValue in await _productAttributeParser.ParseProductAttributeValuesAsync(attributesXml, attribute.Id))
{
var formattedAttribute = $"{attributeName}: {await _localizationService.GetLocalizedAsync(attributeValue, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id)}";
if (renderPrices)
{
if (attributeValue.PriceAdjustmentUsePercentage)
{
if (attributeValue.PriceAdjustment > decimal.Zero)
{
formattedAttribute += string.Format(
await _localizationService.GetResourceAsync("FormattedAttributes.PriceAdjustment"),
"+", attributeValue.PriceAdjustment.ToString("G29"), "%");
}
else if (attributeValue.PriceAdjustment < decimal.Zero)
{
formattedAttribute += string.Format(
await _localizationService.GetResourceAsync("FormattedAttributes.PriceAdjustment"),
string.Empty, attributeValue.PriceAdjustment.ToString("G29"), "%");
}
}
else
{
var attributeValuePriceAdjustment = await _priceCalculationService.GetProductAttributeValuePriceAdjustmentAsync(product, attributeValue, customer);
var(priceAdjustmentBase, _) = await _taxService.GetProductPriceAsync(product, attributeValuePriceAdjustment, customer);
var priceAdjustment = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(priceAdjustmentBase, await _workContext.GetWorkingCurrencyAsync());
if (priceAdjustmentBase > decimal.Zero)
{
formattedAttribute += string.Format(
await _localizationService.GetResourceAsync("FormattedAttributes.PriceAdjustment"),
"+", await _priceFormatter.FormatPriceAsync(priceAdjustment, false, false), string.Empty);
}
else if (priceAdjustmentBase < decimal.Zero)
{
formattedAttribute += string.Format(
await _localizationService.GetResourceAsync("FormattedAttributes.PriceAdjustment"),
"-", await _priceFormatter.FormatPriceAsync(-priceAdjustment, false, false), string.Empty);
}
}
}
//display quantity
if (_shoppingCartSettings.RenderAssociatedAttributeValueQuantity && attributeValue.AttributeValueType == AttributeValueType.AssociatedToProduct)
{
//render only when more than 1
if (attributeValue.Quantity > 1)
{
formattedAttribute += string.Format(await _localizationService.GetResourceAsync("ProductAttributes.Quantity"), attributeValue.Quantity);
}
}
//encode (if required)
if (htmlEncode)
{
formattedAttribute = WebUtility.HtmlEncode(formattedAttribute);
}
if (string.IsNullOrEmpty(formattedAttribute))
{
continue;
}
if (result.Length > 0)
{
result.Append(separator);
}
result.Append(formattedAttribute);
}
}
}
}
//gift cards
if (!renderGiftCardAttributes)
{
return(result.ToString());
}
if (!product.IsGiftCard)
{
return(result.ToString());
}
_productAttributeParser.GetGiftCardAttribute(attributesXml, out var giftCardRecipientName, out var giftCardRecipientEmail, out var giftCardSenderName, out var giftCardSenderEmail, out var _);
//sender
var giftCardFrom = product.GiftCardType == GiftCardType.Virtual ?
string.Format(await _localizationService.GetResourceAsync("GiftCardAttribute.From.Virtual"), giftCardSenderName, giftCardSenderEmail) :
string.Format(await _localizationService.GetResourceAsync("GiftCardAttribute.From.Physical"), giftCardSenderName);
//recipient
var giftCardFor = product.GiftCardType == GiftCardType.Virtual ?
string.Format(await _localizationService.GetResourceAsync("GiftCardAttribute.For.Virtual"), giftCardRecipientName, giftCardRecipientEmail) :
string.Format(await _localizationService.GetResourceAsync("GiftCardAttribute.For.Physical"), giftCardRecipientName);
//encode (if required)
if (htmlEncode)
{
giftCardFrom = WebUtility.HtmlEncode(giftCardFrom);
giftCardFor = WebUtility.HtmlEncode(giftCardFor);
}
if (!string.IsNullOrEmpty(result.ToString()))
{
result.Append(separator);
}
result.Append(giftCardFrom);
result.Append(separator);
result.Append(giftCardFor);
return(result.ToString());
}
public async Task <IViewComponentResult> InvokeAsync(string widgetZone, decimal price)
{
return(View("~/Plugins/Widgets.CartSlideout/Views/_Subtotal.cshtml", await _priceFormatter.FormatPriceAsync(price)));
}
/// <summary>
/// Formats attributes
/// </summary>
/// <param name="attributesXml">Attributes in XML format</param>
/// <param name="customer">Customer</param>
/// <param name="separator">Separator</param>
/// <param name="htmlEncode">A value indicating whether to encode (HTML) values</param>
/// <param name="renderPrices">A value indicating whether to render prices</param>
/// <param name="allowHyperlinks">A value indicating whether to HTML hyperlink tags could be rendered (if required)</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the attributes
/// </returns>
public virtual async Task <string> FormatAttributesAsync(string attributesXml,
Customer customer,
string separator = "<br />",
bool htmlEncode = true,
bool renderPrices = true,
bool allowHyperlinks = true)
{
var result = new StringBuilder();
var attributes = await _checkoutAttributeParser.ParseCheckoutAttributesAsync(attributesXml);
for (var i = 0; i < attributes.Count; i++)
{
var attribute = attributes[i];
var valuesStr = _checkoutAttributeParser.ParseValues(attributesXml, attribute.Id);
for (var j = 0; j < valuesStr.Count; j++)
{
var valueStr = valuesStr[j];
var formattedAttribute = string.Empty;
if (!attribute.ShouldHaveValues())
{
//no values
if (attribute.AttributeControlType == AttributeControlType.MultilineTextbox)
{
//multiline textbox
var attributeName = await _localizationService.GetLocalizedAsync(attribute, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id);
//encode (if required)
if (htmlEncode)
{
attributeName = WebUtility.HtmlEncode(attributeName);
}
formattedAttribute = $"{attributeName}: {HtmlHelper.FormatText(valueStr, false, true, false, false, false, false)}";
//we never encode multiline textbox input
}
else if (attribute.AttributeControlType == AttributeControlType.FileUpload)
{
//file upload
Guid.TryParse(valueStr, out var downloadGuid);
var download = await _downloadService.GetDownloadByGuidAsync(downloadGuid);
if (download != null)
{
string attributeText;
var fileName = $"{download.Filename ?? download.DownloadGuid.ToString()}{download.Extension}";
//encode (if required)
if (htmlEncode)
{
fileName = WebUtility.HtmlEncode(fileName);
}
if (allowHyperlinks)
{
//hyperlinks are allowed
var downloadLink = $"{_webHelper.GetStoreLocation(false)}download/getfileupload/?downloadId={download.DownloadGuid}";
attributeText = $"<a href=\"{downloadLink}\" class=\"fileuploadattribute\">{fileName}</a>";
}
else
{
//hyperlinks aren't allowed
attributeText = fileName;
}
var attributeName = await _localizationService.GetLocalizedAsync(attribute, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id);
//encode (if required)
if (htmlEncode)
{
attributeName = WebUtility.HtmlEncode(attributeName);
}
formattedAttribute = $"{attributeName}: {attributeText}";
}
}
else
{
//other attributes (textbox, datepicker)
formattedAttribute = $"{await _localizationService.GetLocalizedAsync(attribute, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id)}: {valueStr}";
//encode (if required)
if (htmlEncode)
{
formattedAttribute = WebUtility.HtmlEncode(formattedAttribute);
}
}
}
else
{
if (int.TryParse(valueStr, out var attributeValueId))
{
var attributeValue = await _checkoutAttributeService.GetCheckoutAttributeValueByIdAsync(attributeValueId);
if (attributeValue != null)
{
formattedAttribute = $"{await _localizationService.GetLocalizedAsync(attribute, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id)}: {await _localizationService.GetLocalizedAsync(attributeValue, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id)}";
if (renderPrices)
{
var priceAdjustmentBase = (await _taxService.GetCheckoutAttributePriceAsync(attribute, attributeValue, customer)).price;
var priceAdjustment = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(priceAdjustmentBase, await _workContext.GetWorkingCurrencyAsync());
if (priceAdjustmentBase > 0)
{
formattedAttribute += string.Format(
await _localizationService.GetResourceAsync("FormattedAttributes.PriceAdjustment"),
"+", await _priceFormatter.FormatPriceAsync(priceAdjustment), string.Empty);
}
}
}
//encode (if required)
if (htmlEncode)
{
formattedAttribute = WebUtility.HtmlEncode(formattedAttribute);
}
}
}
if (string.IsNullOrEmpty(formattedAttribute))
{
continue;
}
if (i != 0 || j != 0)
{
result.Append(separator);
}
result.Append(formattedAttribute);
}
}
return(result.ToString());
}
/// <summary>
/// Prepare payment method model
/// </summary>
/// <param name="cart">Cart</param>
/// <param name="filterByCountryId">Filter by country identifier</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the payment method model
/// </returns>
public virtual async Task <CheckoutPaymentMethodModel> PreparePaymentMethodModelAsync(IList <ShoppingCartItem> cart, int filterByCountryId)
{
var model = new CheckoutPaymentMethodModel();
//reward points
if (_rewardPointsSettings.Enabled && !await _shoppingCartService.ShoppingCartIsRecurringAsync(cart))
{
var rewardPointsBalance = await _rewardPointService.GetRewardPointsBalanceAsync((await _workContext.GetCurrentCustomerAsync()).Id, (await _storeContext.GetCurrentStoreAsync()).Id);
rewardPointsBalance = _rewardPointService.GetReducedPointsBalance(rewardPointsBalance);
var rewardPointsAmountBase = await _orderTotalCalculationService.ConvertRewardPointsToAmountAsync(rewardPointsBalance);
var rewardPointsAmount = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(rewardPointsAmountBase, await _workContext.GetWorkingCurrencyAsync());
if (rewardPointsAmount > decimal.Zero &&
_orderTotalCalculationService.CheckMinimumRewardPointsToUseRequirement(rewardPointsBalance))
{
model.DisplayRewardPoints = true;
model.RewardPointsAmount = await _priceFormatter.FormatPriceAsync(rewardPointsAmount, true, false);
model.RewardPointsBalance = rewardPointsBalance;
//are points enough to pay for entire order? like if this option (to use them) was selected
model.RewardPointsEnoughToPayForOrder = !await _orderProcessingService.IsPaymentWorkflowRequiredAsync(cart, true);
}
}
//filter by country
var paymentMethods = await(await _paymentPluginManager
.LoadActivePluginsAsyncAsync(await _workContext.GetCurrentCustomerAsync(), (await _storeContext.GetCurrentStoreAsync()).Id, filterByCountryId))
.Where(pm => pm.PaymentMethodType == PaymentMethodType.Standard || pm.PaymentMethodType == PaymentMethodType.Redirection)
.WhereAwait(async pm => !await pm.HidePaymentMethodAsync(cart))
.ToListAsync();
foreach (var pm in paymentMethods)
{
if (await _shoppingCartService.ShoppingCartIsRecurringAsync(cart) && pm.RecurringPaymentType == RecurringPaymentType.NotSupported)
{
continue;
}
var pmModel = new CheckoutPaymentMethodModel.PaymentMethodModel
{
Name = await _localizationService.GetLocalizedFriendlyNameAsync(pm, (await _workContext.GetWorkingLanguageAsync()).Id),
Description = _paymentSettings.ShowPaymentMethodDescriptions ? await pm.GetPaymentMethodDescriptionAsync() : string.Empty,
PaymentMethodSystemName = pm.PluginDescriptor.SystemName,
LogoUrl = await _paymentPluginManager.GetPluginLogoUrlAsync(pm)
};
//payment method additional fee
var paymentMethodAdditionalFee = await _paymentService.GetAdditionalHandlingFeeAsync(cart, pm.PluginDescriptor.SystemName);
var(rateBase, _) = await _taxService.GetPaymentMethodAdditionalFeeAsync(paymentMethodAdditionalFee, await _workContext.GetCurrentCustomerAsync());
var rate = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(rateBase, await _workContext.GetWorkingCurrencyAsync());
if (rate > decimal.Zero)
{
pmModel.Fee = await _priceFormatter.FormatPaymentMethodAdditionalFeeAsync(rate, true);
}
model.PaymentMethods.Add(pmModel);
}
//find a selected (previously) payment method
var selectedPaymentMethodSystemName = await _genericAttributeService.GetAttributeAsync <string>(await _workContext.GetCurrentCustomerAsync(),
NopCustomerDefaults.SelectedPaymentMethodAttribute, (await _storeContext.GetCurrentStoreAsync()).Id);
if (!string.IsNullOrEmpty(selectedPaymentMethodSystemName))
{
var paymentMethodToSelect = model.PaymentMethods.ToList()
.Find(pm => pm.PaymentMethodSystemName.Equals(selectedPaymentMethodSystemName, StringComparison.InvariantCultureIgnoreCase));
if (paymentMethodToSelect != null)
{
paymentMethodToSelect.Selected = true;
}
}
//if no option has been selected, let's do it for the first one
if (model.PaymentMethods.FirstOrDefault(so => so.Selected) == null)
{
var paymentMethodToSelect = model.PaymentMethods.FirstOrDefault();
if (paymentMethodToSelect != null)
{
paymentMethodToSelect.Selected = true;
}
}
return(model);
}
public async Task <IActionResult> GetTodaysOrders()
{
var customer = await _workContext.GetCurrentCustomerAsync();
var orders = await _orderService.SearchOrdersAsync(customerId : customer.Id);
var perviousOrders = orders.Where(x => x.ScheduleDate.Date == DateTime.Now.Date).ToList();
if (perviousOrders.Any())
{
var languageId = _workContext.GetWorkingLanguageAsync().Id;
var model = new CustomerOrderListModel();
foreach (var order in perviousOrders)
{
var orderModel = new CustomerOrderListModel.OrderDetailsModel
{
Id = order.Id,
ScheduleDate = await _dateTimeHelper.ConvertToUserTimeAsync(order.ScheduleDate, DateTimeKind.Utc),
CreatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(order.CreatedOnUtc, DateTimeKind.Utc),
OrderStatusEnum = order.OrderStatus,
OrderStatus = await _localizationService.GetLocalizedEnumAsync(order.OrderStatus),
PaymentStatus = await _localizationService.GetLocalizedEnumAsync(order.PaymentStatus),
ShippingStatus = await _localizationService.GetLocalizedEnumAsync(order.ShippingStatus),
IsReturnRequestAllowed = await _orderProcessingService.IsReturnRequestAllowedAsync(order),
CustomOrderNumber = order.CustomOrderNumber,
Rating = order.Rating,
RatingText = order.RatingText
};
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
orderModel.OrderTotal = await _priceFormatter.FormatPriceAsync(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.GetWorkingLanguageAsync().Id);
var orderItems = await _orderService.GetOrderItemsAsync(order.Id);
foreach (var orderItem in orderItems)
{
var product = await _productService.GetProductByIdAsync(orderItem.ProductId);
var productPicture = await _pictureService.GetPicturesByProductIdAsync(orderItem.ProductId);
var vendor = await _vendorService.GetVendorByProductIdAsync(product.Id);
var orderItemModel = new OrderDetailsModel.OrderItemModel
{
Id = orderItem.Id,
OrderItemGuid = orderItem.OrderItemGuid,
Sku = await _productService.FormatSkuAsync(product, orderItem.AttributesXml),
VendorName = vendor != null ? vendor.Name : string.Empty,
ProductId = product.Id,
ProductPictureUrl = productPicture.Any() ? await _pictureService.GetPictureUrlAsync(productPicture.FirstOrDefault().Id) : await _pictureService.GetDefaultPictureUrlAsync(),
ProductName = await _localizationService.GetLocalizedAsync(product, x => x.Name),
ProductSeName = await _urlRecordService.GetSeNameAsync(product),
Quantity = orderItem.Quantity,
AttributeInfo = orderItem.AttributeDescription,
VendorLogoPictureUrl = await _pictureService.GetPictureUrlAsync(vendor != null?vendor.PictureId : 0, showDefaultPicture : true)
};
//rental info
if (product.IsRental)
{
var rentalStartDate = orderItem.RentalStartDateUtc.HasValue
? _productService.FormatRentalDate(product, orderItem.RentalStartDateUtc.Value) : "";
var rentalEndDate = orderItem.RentalEndDateUtc.HasValue
? _productService.FormatRentalDate(product, orderItem.RentalEndDateUtc.Value) : "";
orderItemModel.RentalInfo = string.Format(await _localizationService.GetResourceAsync("Order.Rental.FormattedDate"),
rentalStartDate, rentalEndDate);
}
orderModel.Items.Add(orderItemModel);
//unit price, subtotal
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = await _priceFormatter.FormatPriceAsync(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
orderItemModel.SubTotal = await _priceFormatter.FormatPriceAsync(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = await _priceFormatter.FormatPriceAsync(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
orderItemModel.SubTotal = await _priceFormatter.FormatPriceAsync(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
}
//downloadable products
if (await _orderService.IsDownloadAllowedAsync(orderItem))
{
orderItemModel.DownloadId = product.DownloadId;
}
if (await _orderService.IsLicenseDownloadAllowedAsync(orderItem))
{
orderItemModel.LicenseId = orderItem.LicenseDownloadId ?? 0;
}
}
model.Orders.Add(orderModel);
}
return(Ok(new { success = true, model }));
}
return(Ok(new { success = false, message = "No previous order found" }));
}