public async Task <IViewComponentResult> InvokeAsync(bool isEditable = false)
{
var orderTotalsEvent = new RenderingOrderTotalsEvent();
await Services.EventPublisher.PublishAsync(orderTotalsEvent);
var currency = Services.WorkContext.WorkingCurrency;
var customer = orderTotalsEvent.Customer ?? Services.WorkContext.CurrentCustomer;
var storeId = orderTotalsEvent.StoreId ?? Services.StoreContext.CurrentStore.Id;
var cart = await _shoppingCartService.GetCartItemsAsync(customer, ShoppingCartType.ShoppingCart, storeId);
var model = new OrderTotalsModel
{
IsEditable = isEditable
};
if (!cart.Any())
{
return(View(model));
}
model.Weight = decimal.Zero;
foreach (var cartItem in cart)
{
model.Weight += cartItem.Item.Product.Weight * cartItem.Item.Quantity;
}
var measureWeight = await _db.MeasureWeights.FindByIdAsync(_measureSettings.BaseWeightId, false);
if (measureWeight != null)
{
model.WeightMeasureUnitName = measureWeight.GetLocalized(x => x.Name);
}
// SubTotal
var cartSubTotal = await _orderCalculationService.GetShoppingCartSubtotalAsync(cart);
var subTotalConverted = _currencyService.ConvertFromPrimaryCurrency(cartSubTotal.SubtotalWithoutDiscount.Amount, currency);
model.SubTotal = subTotalConverted;
if (cartSubTotal.DiscountAmount > decimal.Zero)
{
var subTotalDiscountAmountConverted = _currencyService.ConvertFromPrimaryCurrency(cartSubTotal.DiscountAmount.Amount, currency);
model.SubTotalDiscount = subTotalDiscountAmountConverted * -1;
model.AllowRemovingSubTotalDiscount = cartSubTotal.AppliedDiscount != null &&
cartSubTotal.AppliedDiscount.RequiresCouponCode &&
cartSubTotal.AppliedDiscount.CouponCode.HasValue() &&
model.IsEditable;
}
// Shipping info
// TODO: (ms) (core) Re-implement when any payment method has been implemented
model.RequiresShipping = false;// cart.IsShippingRequired();
if (model.RequiresShipping)
{
var shippingTotal = await _orderCalculationService.GetShoppingCartShippingTotalAsync(cart);
if (shippingTotal.ShippingTotal.HasValue)
{
var shippingTotalConverted = _currencyService.ConvertFromPrimaryCurrency(shippingTotal.ShippingTotal.Value.Amount, currency);
model.Shipping = shippingTotalConverted.ToString();
// Selected shipping method
var shippingOption = customer.GenericAttributes.SelectedShippingOption;
if (shippingOption != null)
{
model.SelectedShippingMethod = shippingOption.Name;
}
}
}
// Payment method fee
var paymentFee = await _orderCalculationService.GetShoppingCartPaymentFeeAsync(cart, customer.GenericAttributes.SelectedPaymentMethod);
var paymentFeeTax = await _taxCalculator.CalculatePaymentFeeTaxAsync(paymentFee.Amount, customer : customer);
if (paymentFeeTax.Price != 0m)
{
var convertedPaymentFeeTax = _currencyService.ConvertFromPrimaryCurrency(paymentFeeTax.Price, currency);
model.PaymentMethodAdditionalFee = convertedPaymentFeeTax;
}
// Tax
var displayTax = true;
var displayTaxRates = true;
if (_taxSettings.HideTaxInOrderSummary && Services.WorkContext.TaxDisplayType == TaxDisplayType.IncludingTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
(Money Price, TaxRatesDictionary TaxRates)cartTaxBase = (new Money(1.19m, currency), new TaxRatesDictionary()); //await _orderCalculationService.GetShoppingCartTaxTotalAsync(cart);
var cartTax = _currencyService.ConvertFromPrimaryCurrency(cartTaxBase.Price.Amount, currency);
if (cartTaxBase.Price == decimal.Zero && _taxSettings.HideZeroTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
displayTaxRates = _taxSettings.DisplayTaxRates && cartTaxBase.TaxRates.Count > 0;
displayTax = !displayTaxRates;
model.Tax = cartTax.ToString(true);
foreach (var taxRate in cartTaxBase.TaxRates)
{
var rate = _taxService.FormatTaxRate(taxRate.Key);
var labelKey = "ShoppingCart.Totals.TaxRateLine" + (Services.WorkContext.TaxDisplayType == TaxDisplayType.IncludingTax ? "Incl" : "Excl");
model.TaxRates.Add(new OrderTotalsModel.TaxRate
{
Rate = rate,
Value = _currencyService.ConvertFromPrimaryCurrency(taxRate.Value, currency),
Label = _localizationService.GetResource(labelKey).FormatCurrent(rate)
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
model.DisplayWeight = _shoppingCartSettings.ShowWeight;
model.ShowConfirmOrderLegalHint = _shoppingCartSettings.ShowConfirmOrderLegalHint;
// Cart total
// TODO: (ms) (core) Re-implement when any payment method has been implemented
//var cartTotal = await _orderCalculationService.GetShoppingCartTotalAsync(cart);
var cartTotal = new ShoppingCartTotal
{
Total = new(decimal.Zero, currency),
ToNearestRounding = new(decimal.Zero, currency),
DiscountAmount = new(15, currency),
AppliedDiscount = (await _db.Discounts.FirstOrDefaultAsync()) ?? new(),
RedeemedRewardPoints = 10,
RedeemedRewardPointsAmount = new(10, currency),
CreditBalance = new(decimal.Zero, currency),
AppliedGiftCards = new() { new() { GiftCard = (await _db.GiftCards.Include(x => x.GiftCardUsageHistory).FirstOrDefaultAsync()) ?? new(), UsableAmount = new(50m, _currencyService.PrimaryCurrency) } },
ConvertedAmount = new ShoppingCartTotal.ConvertedAmounts
{
Total = new(decimal.Zero, currency),
ToNearestRounding = new(decimal.Zero, currency)
}
};
if (cartTotal.ConvertedAmount.Total.HasValue)
{
model.OrderTotal = cartTotal.ConvertedAmount.Total.Value;
if (cartTotal.ConvertedAmount.ToNearestRounding != decimal.Zero)
{
model.OrderTotalRounding = cartTotal.ConvertedAmount.ToNearestRounding;
}
}
// Discount
if (cartTotal.DiscountAmount > decimal.Zero)
{
var orderTotalDiscountAmount = _currencyService.ConvertFromPrimaryCurrency(cartTotal.DiscountAmount.Amount, currency);
model.OrderTotalDiscount = orderTotalDiscountAmount * -1;
model.AllowRemovingOrderTotalDiscount = cartTotal.AppliedDiscount != null &&
cartTotal.AppliedDiscount.RequiresCouponCode &&
cartTotal.AppliedDiscount.CouponCode.HasValue() &&
model.IsEditable;
}
// Gift cards
if (!cartTotal.AppliedGiftCards.IsNullOrEmpty())
{
foreach (var appliedGiftCard in cartTotal.AppliedGiftCards)
{
if (appliedGiftCard?.GiftCard == null)
{
continue;
}
var gcModel = new OrderTotalsModel.GiftCard
{
Id = appliedGiftCard.GiftCard.Id,
CouponCode = appliedGiftCard.GiftCard.GiftCardCouponCode,
};
var amountCanBeUsed = _currencyService.ConvertFromPrimaryCurrency(appliedGiftCard.UsableAmount.Amount, currency);
gcModel.Amount = amountCanBeUsed * -1;
var remainingAmountBase = _giftCardService.GetRemainingAmount(appliedGiftCard.GiftCard) - appliedGiftCard.UsableAmount;
var remainingAmount = _currencyService.ConvertFromPrimaryCurrency(remainingAmountBase.Amount, currency);
gcModel.Remaining = remainingAmount;
model.GiftCards.Add(gcModel);
}
}
// Reward points
if (cartTotal.RedeemedRewardPointsAmount > decimal.Zero)
{
var redeemedRewardPointsAmountInCustomerCurrency = _currencyService.ConvertFromPrimaryCurrency(cartTotal.RedeemedRewardPointsAmount.Amount, currency);
model.RedeemedRewardPoints = cartTotal.RedeemedRewardPoints;
model.RedeemedRewardPointsAmount = (redeemedRewardPointsAmountInCustomerCurrency * -1).ToString(true);
}
// Credit balance.
if (cartTotal.CreditBalance > decimal.Zero)
{
var convertedCreditBalance = _currencyService.ConvertFromPrimaryCurrency(cartTotal.CreditBalance.Amount, currency);
model.CreditBalance = (convertedCreditBalance * -1).ToString(true);
}
return(View(model));
}
public async Task <OrderDetailsModel> PrepareOrderDetailsModelAsync(Order order)
{
Guard.NotNull(order, nameof(order));
var settingFactory = _services.SettingFactory;
var store = await _db.Stores.FindByIdAsync(order.StoreId, false) ?? _services.StoreContext.CurrentStore;
var language = _services.WorkContext.WorkingLanguage;
var orderSettings = await settingFactory.LoadSettingsAsync <OrderSettings>(store.Id);
var catalogSettings = await settingFactory.LoadSettingsAsync <CatalogSettings>(store.Id);
var taxSettings = await settingFactory.LoadSettingsAsync <TaxSettings>(store.Id);
var pdfSettings = await settingFactory.LoadSettingsAsync <PdfSettings>(store.Id);
var addressSettings = await settingFactory.LoadSettingsAsync <AddressSettings>(store.Id);
var companyInfoSettings = await settingFactory.LoadSettingsAsync <CompanyInformationSettings>(store.Id);
var shoppingCartSettings = await settingFactory.LoadSettingsAsync <ShoppingCartSettings>(store.Id);
var mediaSettings = await settingFactory.LoadSettingsAsync <MediaSettings>(store.Id);
var model = new OrderDetailsModel
{
Id = order.Id,
StoreId = order.StoreId,
CustomerLanguageId = order.CustomerLanguageId,
CustomerComment = order.CustomerOrderComment,
OrderNumber = order.GetOrderNumber(),
CreatedOn = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc),
OrderStatus = await _services.Localization.GetLocalizedEnumAsync(order.OrderStatus),
IsReOrderAllowed = orderSettings.IsReOrderAllowed,
IsReturnRequestAllowed = _orderProcessingService.IsReturnRequestAllowed(order),
DisplayPdfInvoice = pdfSettings.Enabled,
RenderOrderNotes = pdfSettings.RenderOrderNotes,
// Shipping info.
ShippingStatus = await _services.Localization.GetLocalizedEnumAsync(order.ShippingStatus)
};
// TODO: refactor modelling for multi-order processing.
var companyCountry = await _db.Countries.FindByIdAsync(companyInfoSettings.CountryId, false);
model.MerchantCompanyInfo = companyInfoSettings;
model.MerchantCompanyCountryName = companyCountry?.GetLocalized(x => x.Name);
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
await MapperFactory.MapAsync(order.ShippingAddress, model.ShippingAddress);
model.ShippingMethod = order.ShippingMethod;
// Shipments (only already shipped).
var shipments = order.Shipments.Where(x => x.ShippedDateUtc.HasValue).OrderBy(x => x.CreatedOnUtc).ToList();
foreach (var shipment in shipments)
{
var shipmentModel = new OrderDetailsModel.ShipmentBriefModel
{
Id = shipment.Id,
TrackingNumber = shipment.TrackingNumber,
};
if (shipment.ShippedDateUtc.HasValue)
{
shipmentModel.ShippedDate = _dateTimeHelper.ConvertToUserTime(shipment.ShippedDateUtc.Value, DateTimeKind.Utc);
}
if (shipment.DeliveryDateUtc.HasValue)
{
shipmentModel.DeliveryDate = _dateTimeHelper.ConvertToUserTime(shipment.DeliveryDateUtc.Value, DateTimeKind.Utc);
}
model.Shipments.Add(shipmentModel);
}
}
await MapperFactory.MapAsync(order.BillingAddress, model.BillingAddress);
model.VatNumber = order.VatNumber;
// Payment method.
var paymentMethod = await _paymentService.LoadPaymentMethodBySystemNameAsync(order.PaymentMethodSystemName);
model.PaymentMethodSystemName = order.PaymentMethodSystemName;
// TODO: (mh) (core)
//model.PaymentMethod = paymentMethod != null ? _pluginMediator.GetLocalizedFriendlyName(paymentMethod.Metadata) : order.PaymentMethodSystemName;
model.PaymentMethod = order.PaymentMethodSystemName;
model.CanRePostProcessPayment = await _paymentService.CanRePostProcessPaymentAsync(order);
// Purchase order number (we have to find a better to inject this information because it's related to a certain plugin).
if (paymentMethod != null && paymentMethod.Metadata.SystemName.Equals("Smartstore.PurchaseOrderNumber", StringComparison.InvariantCultureIgnoreCase))
{
model.DisplayPurchaseOrderNumber = true;
model.PurchaseOrderNumber = order.PurchaseOrderNumber;
}
if (order.AllowStoringCreditCardNumber)
{
model.CardNumber = _encryptor.DecryptText(order.CardNumber);
model.MaskedCreditCardNumber = _encryptor.DecryptText(order.MaskedCreditCardNumber);
model.CardCvv2 = _encryptor.DecryptText(order.CardCvv2);
model.CardExpirationMonth = _encryptor.DecryptText(order.CardExpirationMonth);
model.CardExpirationYear = _encryptor.DecryptText(order.CardExpirationYear);
}
if (order.AllowStoringDirectDebit)
{
model.DirectDebitAccountHolder = _encryptor.DecryptText(order.DirectDebitAccountHolder);
model.DirectDebitAccountNumber = _encryptor.DecryptText(order.DirectDebitAccountNumber);
model.DirectDebitBankCode = _encryptor.DecryptText(order.DirectDebitBankCode);
model.DirectDebitBankName = _encryptor.DecryptText(order.DirectDebitBankName);
model.DirectDebitBIC = _encryptor.DecryptText(order.DirectDebitBIC);
model.DirectDebitCountry = _encryptor.DecryptText(order.DirectDebitCountry);
model.DirectDebitIban = _encryptor.DecryptText(order.DirectDebitIban);
}
// TODO: (mh) (core) Reimplement when pricing is ready.
// Totals.
var customerCurrency = await _db.Currencies
.AsNoTracking()
.Where(x => x.CurrencyCode == order.CustomerCurrencyCode)
.FirstOrDefaultAsync();
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
// Order subtotal.
var orderSubtotalExclTax = _currencyService.ConvertToExchangeRate(order.OrderSubtotalExclTax, order.CurrencyRate, customerCurrency);
model.OrderSubtotal = orderSubtotalExclTax.ToString();
// Discount (applied to order subtotal).
var orderSubTotalDiscountExclTax = _currencyService.ConvertToExchangeRate(order.OrderSubTotalDiscountExclTax, order.CurrencyRate, customerCurrency);
if (orderSubTotalDiscountExclTax > 0)
{
model.OrderSubTotalDiscount = (orderSubTotalDiscountExclTax * -1).ToString();
}
// Order shipping.
var orderShippingExclTax = _currencyService.ConvertToExchangeRate(order.OrderShippingExclTax, order.CurrencyRate, customerCurrency);
model.OrderShipping = orderShippingExclTax.ToString();
// Payment method additional fee.
var paymentMethodAdditionalFeeExclTax = _currencyService.ConvertToExchangeRate(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate, customerCurrency);
if (paymentMethodAdditionalFeeExclTax != 0)
{
model.PaymentMethodAdditionalFee = paymentMethodAdditionalFeeExclTax.ToString();
}
}
break;
case TaxDisplayType.IncludingTax:
{
// Order subtotal.
var orderSubtotalInclTax = _currencyService.ConvertToExchangeRate(order.OrderSubtotalInclTax, order.CurrencyRate, customerCurrency);
model.OrderSubtotal = orderSubtotalInclTax.ToString();
// Discount (applied to order subtotal).
var orderSubTotalDiscountInclTax = _currencyService.ConvertToExchangeRate(order.OrderSubTotalDiscountInclTax, order.CurrencyRate, customerCurrency);
if (orderSubTotalDiscountInclTax > 0)
{
model.OrderSubTotalDiscount = (orderSubTotalDiscountInclTax * -1).ToString();
}
// Order shipping.
var orderShippingInclTax = _currencyService.ConvertToExchangeRate(order.OrderShippingInclTax, order.CurrencyRate, customerCurrency);
model.OrderShipping = orderShippingInclTax.ToString();
// Payment method additional fee.
var paymentMethodAdditionalFeeInclTax = _currencyService.ConvertToExchangeRate(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate, customerCurrency);
if (paymentMethodAdditionalFeeInclTax != 0)
{
model.PaymentMethodAdditionalFee = paymentMethodAdditionalFeeInclTax.ToString();
}
}
break;
}
// Tax.
var displayTax = true;
var displayTaxRates = true;
if (taxSettings.HideTaxInOrderSummary && order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
if (order.OrderTax == 0 && taxSettings.HideZeroTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
displayTaxRates = taxSettings.DisplayTaxRates && order.TaxRatesDictionary.Count > 0;
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertToExchangeRate(order.OrderTax, order.CurrencyRate, customerCurrency);
model.Tax = orderTaxInCustomerCurrency.ToString();
foreach (var tr in order.TaxRatesDictionary)
{
var rate = _taxService.FormatTaxRate(tr.Key);
var labelKey = _services.WorkContext.TaxDisplayType == TaxDisplayType.IncludingTax ? "ShoppingCart.Totals.TaxRateLineIncl" : "ShoppingCart.Totals.TaxRateLineExcl";
model.TaxRates.Add(new OrderDetailsModel.TaxRate
{
Rate = rate,
Label = T(labelKey, rate),
Value = _currencyService.ConvertToExchangeRate(tr.Value, order.CurrencyRate, customerCurrency).ToString()
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
// Discount (applied to order total).
var orderDiscountInCustomerCurrency = _currencyService.ConvertToExchangeRate(order.OrderDiscount, order.CurrencyRate, customerCurrency);
if (orderDiscountInCustomerCurrency > 0)
{
model.OrderTotalDiscount = (orderDiscountInCustomerCurrency * -1).ToString();
}
// Gift cards.
foreach (var gcuh in order.GiftCardUsageHistory)
{
var remainingAmountBase = _giftCardService.GetRemainingAmount(gcuh.GiftCard);
var remainingAmount = _currencyService.ConvertToExchangeRate(remainingAmountBase.Amount, order.CurrencyRate, customerCurrency);
var usedAmount = _currencyService.ConvertToExchangeRate(gcuh.UsedValue, order.CurrencyRate, customerCurrency);
var gcModel = new OrderDetailsModel.GiftCard
{
CouponCode = gcuh.GiftCard.GiftCardCouponCode,
Amount = (usedAmount * -1).ToString(),
Remaining = remainingAmount.ToString()
};
model.GiftCards.Add(gcModel);
}
// Reward points .
if (order.RedeemedRewardPointsEntry != null)
{
var usedAmount = _currencyService.ConvertToExchangeRate(order.RedeemedRewardPointsEntry.UsedAmount, order.CurrencyRate, customerCurrency);
model.RedeemedRewardPoints = -order.RedeemedRewardPointsEntry.Points;
model.RedeemedRewardPointsAmount = (usedAmount * -1).ToString();
}
// Credit balance.
if (order.CreditBalance > 0)
{
var convertedCreditBalance = _currencyService.ConvertToExchangeRate(order.CreditBalance, order.CurrencyRate, customerCurrency);
model.CreditBalance = (convertedCreditBalance * -1).ToString();
}
// Total.
(var orderTotal, var roundingAmount) = await _orderService.GetOrderTotalInCustomerCurrencyAsync(order, customerCurrency);
model.OrderTotal = orderTotal.ToString();
if (roundingAmount != 0)
{
model.OrderTotalRounding = roundingAmount.ToString();
}
// Checkout attributes.
model.CheckoutAttributeInfo = HtmlUtils.ConvertPlainTextToTable(HtmlUtils.ConvertHtmlToPlainText(order.CheckoutAttributeDescription));
// Order notes.
await _db.LoadCollectionAsync(order, x => x.OrderNotes);
var orderNotes = order.OrderNotes
.Where(x => x.DisplayToCustomer)
.OrderByDescending(x => x.CreatedOnUtc)
.ToList();
foreach (var orderNote in orderNotes)
{
var createdOn = _dateTimeHelper.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc);
model.OrderNotes.Add(new OrderDetailsModel.OrderNote
{
Note = orderNote.FormatOrderNoteText(),
CreatedOn = createdOn,
FriendlyCreatedOn = orderNote.CreatedOnUtc.Humanize()
});
}
// Purchased products.
model.ShowSku = catalogSettings.ShowProductSku;
model.ShowProductImages = shoppingCartSettings.ShowProductImagesOnShoppingCart;
model.ShowProductBundleImages = shoppingCartSettings.ShowProductBundleImagesOnShoppingCart;
model.BundleThumbSize = mediaSettings.CartThumbBundleItemPictureSize;
await _db.LoadCollectionAsync(order, x => x.OrderItems, false, q => q.Include(x => x.Product));
foreach (var orderItem in order.OrderItems)
{
var orderItemModel = await PrepareOrderItemModelAsync(order, orderItem, catalogSettings, shoppingCartSettings, mediaSettings, customerCurrency);
model.Items.Add(orderItemModel);
}
return(model);
}
