public ActionResult UsageHistoryList(int giftCardId, GridCommand command)
{
var model = new GridModel <GiftCardModel.GiftCardUsageHistoryModel>();
var giftCard = _giftCardService.GetGiftCardById(giftCardId);
var usageHistoryModel = giftCard.GiftCardUsageHistory
.OrderByDescending(gcuh => gcuh.CreatedOnUtc)
.Select(x =>
{
return(new GiftCardModel.GiftCardUsageHistoryModel()
{
Id = x.Id,
OrderId = x.UsedWithOrderId,
UsedValue = _priceFormatter.FormatPrice(x.UsedValue, true, false),
CreatedOn = _dateTimeHelper.ConvertToUserTime(x.CreatedOnUtc, DateTimeKind.Utc)
});
})
.ToList();
model.Data = usageHistoryModel.PagedForCommand(command);
model.Total = usageHistoryModel.Count;
return(new JsonResult
{
Data = model
});
}
public ActionResult Edit(int id)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageGiftCards))
{
return(AccessDeniedView());
}
var giftCard = _giftCardService.GetGiftCardById(id);
if (giftCard == null)
{
//No gift card found with the specified id
return(RedirectToAction("List"));
}
var model = giftCard.ToModel();
model.PurchasedWithOrderId = giftCard.PurchasedWithOrderItem != null ? (int?)giftCard.PurchasedWithOrderItem.OrderId : null;
model.RemainingAmountStr = _priceFormatter.FormatPrice(giftCard.GetGiftCardRemainingAmount(), true, false);
model.AmountStr = _priceFormatter.FormatPrice(giftCard.Amount, true, false);
model.CreatedOn = _dateTimeHelper.ConvertToUserTime(giftCard.CreatedOnUtc, DateTimeKind.Utc);
model.PrimaryStoreCurrencyCode = _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode;
return(View(model));
}
public async Task <IActionResult> Edit(string id)
{
var giftCard = await _giftCardService.GetGiftCardById(id);
if (giftCard == null)
{
//No gift card found with the specified id
return(RedirectToAction("List"));
}
var model = await _giftCardViewModelService.PrepareGiftCardModel(giftCard);
return(View(model));
}
public void Can_validate_giftCard()
{
RunWithTestServiceProvider(() => {
var gc = _giftCardService.GetGiftCardById(1);
_giftCardService.InsertGiftCardUsageHistory(
new GiftCardUsageHistory
{
GiftCardId = gc.Id,
UsedValue = 30
});
_giftCardService.InsertGiftCardUsageHistory(
new GiftCardUsageHistory
{
GiftCardId = gc.Id,
UsedValue = 20
});
_giftCardService.InsertGiftCardUsageHistory(
new GiftCardUsageHistory
{
GiftCardId = gc.Id,
UsedValue = 5
});
//valid
_giftCardService.IsGiftCardValid(gc).Should().BeTrue();
//mark as not active
gc.IsGiftCardActivated = false;
_giftCardService.IsGiftCardValid(gc).Should().BeFalse();
//again active
gc.IsGiftCardActivated = true;
_giftCardService.IsGiftCardValid(gc).Should().BeTrue();
//add usage history record
_giftCardService.InsertGiftCardUsageHistory(
new GiftCardUsageHistory
{
GiftCardId = gc.Id,
UsedValue = 1000
});
_giftCardService.IsGiftCardValid(gc).Should().BeFalse();
});
}
public virtual async Task <IActionResult> RemoveGiftCardCode(string giftCardId, [FromServices] IGiftCardService giftCardService)
{
if (!string.IsNullOrEmpty(giftCardId))
{
//remove card
var giftcard = await giftCardService.GetGiftCardById(giftCardId);
if (giftcard != null)
{
var result = _workContext.CurrentCustomer.RemoveCouponCode(SystemCustomerAttributeNames.GiftCardCoupons, giftcard.GiftCardCouponCode);
await _genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, SystemCustomerAttributeNames.GiftCardCoupons, result);
}
}
var cart = _shoppingCartService.GetShoppingCart(_storeContext.CurrentStore.Id, PrepareCartTypes());
var model = await _mediator.Send(new GetShoppingCart()
{
Cart = cart,
Customer = _workContext.CurrentCustomer,
Currency = _workContext.WorkingCurrency,
Language = _workContext.WorkingLanguage,
Store = _storeContext.CurrentStore,
TaxDisplayType = _workContext.TaxDisplayType
});
return(Json(new
{
cart = RenderViewComponentToString("OrderSummary", new { overriddenModel = model })
}));
}
public async Task <bool> Handle(RemoveGiftCardCommand request, CancellationToken cancellationToken)
{
if (request.Customer == null)
{
throw new ArgumentNullException("customer");
}
var giftCard = await _giftCardService.GetGiftCardById(request.GiftCardId);
if (giftCard == null)
{
throw new ArgumentNullException("giftCard");
}
//get applied coupon codes
var existingCouponCodes = request.Customer.ParseAppliedGiftCardCouponCodes();
//clear them
await _genericAttributeService.SaveAttribute <string>(request.Customer, SystemCustomerAttributeNames.GiftCardCouponCodes, null);
//save again except removed one
foreach (string existingCouponCode in existingCouponCodes)
{
if (!existingCouponCode.Equals(giftCard.GiftCardCouponCode, StringComparison.OrdinalIgnoreCase))
{
var result = GiftCardExtensions.ApplyCouponCode(request.Customer.GetAttributeFromEntity <string>(SystemCustomerAttributeNames.GiftCardCouponCodes),
existingCouponCode);
await _genericAttributeService.SaveAttribute(request.Customer, SystemCustomerAttributeNames.GiftCardCouponCodes, result);
}
}
return(true);
}
public ActionResult DeleteConfirmed(int id)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageGiftCards))
return AccessDeniedView();
var giftCard = _giftCardService.GetGiftCardById(id);
if (giftCard == null)
//No gift card found with the specified id
return RedirectToAction("List");
_giftCardService.DeleteGiftCard(giftCard);
//activity log
_customerActivityService.InsertActivity("DeleteGiftCard", _localizationService.GetResource("ActivityLog.DeleteGiftCard"), giftCard.GiftCardCouponCode);
SuccessNotification(_localizationService.GetResource("Admin.GiftCards.Deleted"));
return RedirectToAction("List");
}
public virtual IActionResult Edit(int id)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageGiftCards))
{
return(AccessDeniedView());
}
//try to get a gift card with the specified id
var giftCard = _giftCardService.GetGiftCardById(id);
if (giftCard == null)
{
return(RedirectToAction("List"));
}
//prepare model
var model = _giftCardModelFactory.PrepareGiftCardModel(null, giftCard);
return(View(model));
}
private async Task PrepareGiftCards(GetOrderDetails request, OrderDetailsModel model)
{
foreach (var gcuh in await _giftCardService.GetAllGiftCardUsageHistory(request.Order.Id))
{
var giftCard = await _giftCardService.GetGiftCardById(gcuh.GiftCardId);
model.GiftCards.Add(new OrderDetailsModel.GiftCard {
CouponCode = giftCard.GiftCardCouponCode,
Amount = await _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(gcuh.UsedValue, request.Order.CurrencyRate)), true, request.Order.CustomerCurrencyCode, false, request.Language),
});
}
}
public virtual async Task <IActionResult> RemoveGiftCardCode(string giftCardId)
{
var model = new ShoppingCartModel();
//get gift card identifier
var gc = await _giftCardService.GetGiftCardById(giftCardId);
if (gc != null)
{
await _workContext.CurrentCustomer.RemoveGiftCardCouponCode(_genericAttributeService, gc.GiftCardCouponCode);
}
var cart = _shoppingCartService.GetShoppingCart(_storeContext.CurrentStore.Id, ShoppingCartType.ShoppingCart, ShoppingCartType.Auctions);
await _shoppingCartViewModelService.PrepareShoppingCart(model, cart);
return(Json(new
{
cart = this.RenderViewComponentToString("OrderSummary", new { overriddenModel = model })
}));
}
public virtual IActionResult RemoveGiftCardCode(string giftCardId)
{
var model = new ShoppingCartModel();
//get gift card identifier
var gc = _giftCardService.GetGiftCardById(giftCardId);
if (gc != null)
{
_workContext.CurrentCustomer.RemoveGiftCardCouponCode(gc.GiftCardCouponCode);
}
var cart = _workContext.CurrentCustomer.ShoppingCartItems
.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart || sci.ShoppingCartType == ShoppingCartType.Auctions)
.LimitPerStore(_storeContext.CurrentStore.Id)
.ToList();
_shoppingCartViewModelService.PrepareShoppingCart(model, cart);
return(Json(new
{
cart = this.RenderViewComponentToString("OrderSummary", new { overriddenModel = model })
}));
}
public async Task <LiquidOrder> Handle(GetOrderTokensCommand request, CancellationToken cancellationToken)
{
var language = await _languageService.GetLanguageById(request.Order.CustomerLanguageId);
var currency = await _currencyService.GetCurrencyByCode(request.Order.CustomerCurrencyCode);
var liquidOrder = new LiquidOrder(request.Order, request.Customer, language, currency, request.Store, request.OrderNote, request.Vendor);
foreach (var item in request.Order.OrderItems.Where(x => x.VendorId == request.Vendor?.Id || request.Vendor == null))
{
var product = await _productService.GetProductById(item.ProductId);
Vendor vendorItem = string.IsNullOrEmpty(item.VendorId) ? null : await _vendorService.GetVendorById(item.VendorId);
var liqitem = new LiquidOrderItem(item, product, request.Order, language, currency, request.Store, vendorItem);
#region Download
liqitem.IsDownloadAllowed = _downloadService.IsDownloadAllowed(request.Order, item, product);
liqitem.IsLicenseDownloadAllowed = _downloadService.IsLicenseDownloadAllowed(request.Order, item, product);
#endregion
#region Unit price
string unitPriceStr;
if (request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
unitPriceStr = _priceFormatter.FormatPrice(item.UnitPriceInclTax, true, currency, language, true);
}
else
{
//excluding tax
unitPriceStr = _priceFormatter.FormatPrice(item.UnitPriceExclTax, true, currency, language, false);
}
liqitem.UnitPrice = unitPriceStr;
#endregion
#region total price
string priceStr;
if (request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
priceStr = _priceFormatter.FormatPrice(item.PriceInclTax, true, currency, language, true);
}
else
{
//excluding tax
priceStr = _priceFormatter.FormatPrice(item.PriceExclTax, true, currency, language, false);
}
liqitem.TotalPrice = priceStr;
#endregion
string sku = "";
if (product != null)
{
sku = product.FormatSku(item.AttributesXml, _productAttributeParser);
}
liqitem.ProductSku = WebUtility.HtmlEncode(sku);
liqitem.ShowSkuOnProductDetailsPage = _catalogSettings.ShowSkuOnProductDetailsPage;
liqitem.ProductOldPrice = _priceFormatter.FormatPrice(product.OldPrice, true, currency, language, true);
liquidOrder.OrderItems.Add(liqitem);
}
liquidOrder.BillingCustomAttributes = await _addressAttributeFormatter.FormatAttributes(request.Order.BillingAddress?.CustomAttributes);
liquidOrder.BillingCountry = request.Order.BillingAddress != null && !string.IsNullOrEmpty(request.Order.BillingAddress.CountryId) ? (await _countryService.GetCountryById(request.Order.BillingAddress.CountryId))?.GetLocalized(x => x.Name, request.Order.CustomerLanguageId) : "";
liquidOrder.BillingStateProvince = !string.IsNullOrEmpty(request.Order.BillingAddress.StateProvinceId) ? (await _stateProvinceService.GetStateProvinceById(request.Order.BillingAddress.StateProvinceId))?.GetLocalized(x => x.Name, request.Order.CustomerLanguageId) : "";
liquidOrder.ShippingCountry = request.Order.ShippingAddress != null && !string.IsNullOrEmpty(request.Order.ShippingAddress.CountryId) ? (await _countryService.GetCountryById(request.Order.ShippingAddress.CountryId))?.GetLocalized(x => x.Name, request.Order.CustomerLanguageId) : "";
liquidOrder.ShippingStateProvince = request.Order.ShippingAddress != null && !string.IsNullOrEmpty(request.Order.ShippingAddress.StateProvinceId) ? (await _stateProvinceService.GetStateProvinceById(request.Order.ShippingAddress.StateProvinceId)).GetLocalized(x => x.Name, request.Order.CustomerLanguageId) : "";
liquidOrder.ShippingCustomAttributes = await _addressAttributeFormatter.FormatAttributes(request.Order.ShippingAddress != null?request.Order.ShippingAddress.CustomAttributes : "");
var paymentMethod = _paymentService.LoadPaymentMethodBySystemName(request.Order.PaymentMethodSystemName);
liquidOrder.PaymentMethod = paymentMethod != null?paymentMethod.GetLocalizedFriendlyName(_localizationService, language.Id) : request.Order.PaymentMethodSystemName;
liquidOrder.AmountRefunded = _priceFormatter.FormatPrice(request.RefundedAmount, true, currency, language, false);
Dictionary <string, string> dict = new Dictionary <string, string>();
foreach (var item in request.Order.OrderTaxes)
{
string taxRate = string.Format(_localizationService.GetResource("Messages.Order.TaxRateLine"), _priceFormatter.FormatTaxRate(item.Percent));
string taxValue = _priceFormatter.FormatPrice(item.Amount, true, currency, language, false);
dict.Add(taxRate, taxValue);
}
liquidOrder.TaxRates = dict;
Dictionary <string, string> cards = new Dictionary <string, string>();
var gcuhC = await _giftCardService.GetAllGiftCardUsageHistory(request.Order.Id);
foreach (var gcuh in gcuhC)
{
var giftCard = await _giftCardService.GetGiftCardById(gcuh.GiftCardId);
string giftCardText = string.Format(_localizationService.GetResource("Messages.Order.GiftCardInfo", language.Id), WebUtility.HtmlEncode(giftCard.GiftCardCouponCode));
string giftCardAmount = _priceFormatter.FormatPrice(-gcuh.UsedValue, true, currency, language, false);
cards.Add(giftCardText, giftCardAmount);
}
liquidOrder.GiftCards = cards;
if (request.Order.RedeemedRewardPointsEntry != null)
{
liquidOrder.RPTitle = string.Format(_localizationService.GetResource("Messages.Order.RewardPoints", language.Id), -request.Order.RedeemedRewardPointsEntry?.Points);
liquidOrder.RPAmount = _priceFormatter.FormatPrice(-request.Order.RedeemedRewardPointsEntry.UsedAmount, true, currency, language, false);
}
void CalculateSubTotals()
{
string _cusSubTotal;
bool _displaySubTotalDiscount;
string _cusSubTotalDiscount;
string _cusShipTotal;
string _cusPaymentMethodAdditionalFee;
bool _displayTax;
string _cusTaxTotal;
bool _displayTaxRates;
bool _displayDiscount;
string _cusDiscount;
string _cusTotal;
_displaySubTotalDiscount = false;
_cusSubTotalDiscount = string.Empty;
if (request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal)
{
//including tax
//subtotal
_cusSubTotal = _priceFormatter.FormatPrice(request.Order.OrderSubtotalInclTax, true, currency, language, true);
//discount (applied to order subtotal)
if (request.Order.OrderSubTotalDiscountInclTax > decimal.Zero)
{
_cusSubTotalDiscount = _priceFormatter.FormatPrice(-request.Order.OrderSubTotalDiscountInclTax, true, currency, language, true);
_displaySubTotalDiscount = true;
}
}
else
{
//exсluding tax
//subtotal
_cusSubTotal = _priceFormatter.FormatPrice(request.Order.OrderSubtotalExclTax, true, currency, language, false);
//discount (applied to order subtotal)
if (request.Order.OrderSubTotalDiscountExclTax > decimal.Zero)
{
_cusSubTotalDiscount = _priceFormatter.FormatPrice(-request.Order.OrderSubTotalDiscountExclTax, true, currency, language, false);
_displaySubTotalDiscount = true;
}
}
//shipping, payment method fee
_cusTaxTotal = string.Empty;
_cusDiscount = string.Empty;
if (request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
//shipping
_cusShipTotal = _priceFormatter.FormatShippingPrice(request.Order.OrderShippingInclTax, true, currency, language, true);
//payment method additional fee
_cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(request.Order.PaymentMethodAdditionalFeeInclTax, true, currency, language, true);
}
else
{
//excluding tax
//shipping
_cusShipTotal = _priceFormatter.FormatShippingPrice(request.Order.OrderShippingExclTax, true, currency, language, false);
//payment method additional fee
_cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(request.Order.PaymentMethodAdditionalFeeExclTax, true, currency, language, false);
}
//shipping
bool displayShipping = request.Order.ShippingStatus != ShippingStatus.ShippingNotRequired;
//payment method fee
bool displayPaymentMethodFee = request.Order.PaymentMethodAdditionalFeeExclTax > decimal.Zero;
//tax
_displayTax = true;
_displayTaxRates = true;
if (_taxSettings.HideTaxInOrderSummary && request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
_displayTax = false;
_displayTaxRates = false;
}
else
{
if (request.Order.OrderTax == 0 && _taxSettings.HideZeroTax)
{
_displayTax = false;
_displayTaxRates = false;
}
else
{
_displayTaxRates = _taxSettings.DisplayTaxRates && request.Order.OrderTaxes.Any();
_displayTax = !_displayTaxRates;
string taxStr = _priceFormatter.FormatPrice(request.Order.OrderTax, true, currency, language, request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
_cusTaxTotal = taxStr;
}
}
//discount
_displayDiscount = false;
if (request.Order.OrderDiscount > decimal.Zero)
{
_cusDiscount = _priceFormatter.FormatPrice(-request.Order.OrderDiscount, true, currency, language, request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
_displayDiscount = true;
}
//total
_cusTotal = _priceFormatter.FormatPrice(request.Order.OrderTotal, true, currency, language, request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
liquidOrder.SubTotal = _cusSubTotal;
liquidOrder.DisplaySubTotalDiscount = _displaySubTotalDiscount;
liquidOrder.SubTotalDiscount = _cusSubTotalDiscount;
liquidOrder.Shipping = _cusShipTotal;
liquidOrder.Discount = _cusDiscount;
liquidOrder.PaymentMethodAdditionalFee = _cusPaymentMethodAdditionalFee;
liquidOrder.Tax = _cusTaxTotal;
liquidOrder.Total = _cusTotal;
liquidOrder.DisplayTax = _displayTax;
liquidOrder.DisplayDiscount = _displayDiscount;
liquidOrder.DisplayTaxRates = _displayTaxRates;
}
CalculateSubTotals();
return(liquidOrder);
}
private void SyncCartWithKlarnaOrder(Customer customer, KlarnaCheckoutOrder klarnaCheckoutOrder)
{
var currentStoreId = _storeContext.CurrentStore.Id;
var orderCurrency = _currencyService.GetCurrencyByCode(klarnaCheckoutOrder.PurchaseCurrency);
if (orderCurrency != null)
{
_workContext.WorkingCurrency = orderCurrency;
}
ClearItemsInCart(customer, currentStoreId);
ClearDiscountsAndShippingSelection(customer, currentStoreId);
var physicalItems = klarnaCheckoutOrder.Cart.Items.Where(x => x.Type == CartItem.TypePhysical);
var appliedCoupons = klarnaCheckoutOrder.Cart.Items.Where(x => x.Type == CartItem.TypeDiscount && x.HasOrderLevelDiscountCouponCode());
var appliedGiftCards = klarnaCheckoutOrder.Cart.Items.Where(x => x.Type == CartItem.TypeDiscount && x.IsDiscountGiftCardCartItem());
var appliedRewardPoints = klarnaCheckoutOrder.Cart.Items.Where(x => x.Type == CartItem.TypeDiscount && x.IsRewardPointsCartItem());
var checkoutAttributes = klarnaCheckoutOrder.Cart.Items.Where(x => x.Type == CartItem.TypeDiscount && x.IsCheckoutAttribtue());
var shippingItems = klarnaCheckoutOrder.Cart.Items.Where(x => x.Type == CartItem.TypeShippingFee);
foreach (var physicalItem in physicalItems)
{
AddPhysicalItemToCart(customer, physicalItem, currentStoreId);
var couponCodes = physicalItem.GetCouponCodesFromPhysicalCartItem();
foreach (var couponCode in couponCodes)
{
UseCouponCode(customer, couponCode);
}
}
foreach (var coupon in appliedCoupons)
{
var couponCode = coupon.GetCouponCodeFromDiscountCouponCartItem();
UseCouponCode(customer, couponCode);
}
foreach (var giftCardCartItem in appliedGiftCards)
{
var giftCardId = giftCardCartItem.GetGiftCardIdFromDiscountGiftCardCartItem();
var giftCard = _giftCardService.GetGiftCardById(giftCardId);
customer.ApplyGiftCardCouponCode(giftCard.GiftCardCouponCode);
}
if (appliedRewardPoints.Any())
{
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.UseRewardPointsDuringCheckout, true, currentStoreId);
}
var checkoutAttributesXml = GetSelectedCheckoutAttributesThatHasNotBeenSentToKlarna(customer, currentStoreId);
foreach (var item in checkoutAttributes)
{
var ca = _checkoutAttributeService.GetCheckoutAttributeById(item.GetCheckoutAttributeId());
checkoutAttributesXml = _checkoutAttributeParser.AddCheckoutAttribute(checkoutAttributesXml, ca, item.GetCheckoutAttributeValue());
}
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.CheckoutAttributes, checkoutAttributesXml, currentStoreId);
foreach (var shippingItem in shippingItems)
{
AddShippingItemToCart(customer, shippingItem, currentStoreId);
var couponCodes = shippingItem.GetCouponCodesFromShippingItem();
foreach (var couponCode in couponCodes)
{
UseCouponCode(customer, couponCode);
}
}
}
public virtual async Task <OrderDetailsModel> PrepareOrderDetails(Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
var model = new OrderDetailsModel();
model.Id = order.Id;
model.OrderNumber = order.OrderNumber;
model.CreatedOn = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc);
model.OrderStatus = order.OrderStatus.GetLocalizedEnum(_localizationService, _workContext);
model.IsReOrderAllowed = _orderSettings.IsReOrderAllowed;
model.IsReturnRequestAllowed = await _orderProcessingService.IsReturnRequestAllowed(order);
model.PdfInvoiceDisabled = _pdfSettings.DisablePdfInvoicesForPendingOrders && order.OrderStatus == OrderStatus.Pending;
model.ShowAddOrderNote = _orderSettings.AllowCustomerToAddOrderNote;
//shipping info
model.ShippingStatus = order.ShippingStatus.GetLocalizedEnum(_localizationService, _workContext);
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.PickUpInStore = order.PickUpInStore;
if (!order.PickUpInStore)
{
await _addressViewModelService.PrepareModel(model : model.ShippingAddress,
address : order.ShippingAddress,
excludeProperties : false);
}
else
{
if (order.PickupPoint != null)
{
if (order.PickupPoint.Address != null)
{
var country = await _countryService.GetCountryById(order.PickupPoint.Address.CountryId);
model.PickupAddress = new AddressModel
{
Address1 = order.PickupPoint.Address.Address1,
City = order.PickupPoint.Address.City,
CountryName = country != null ? country.Name : string.Empty,
ZipPostalCode = order.PickupPoint.Address.ZipPostalCode
};
}
}
}
model.ShippingMethod = order.ShippingMethod;
model.ShippingAdditionDescription = order.ShippingOptionAttributeDescription;
//shipments (only already shipped)
var shipments = (await _shipmentService.GetShipmentsByOrder(order.Id)).Where(x => x.ShippedDateUtc.HasValue).OrderBy(x => x.CreatedOnUtc).ToList();
foreach (var shipment in shipments)
{
var shipmentModel = new OrderDetailsModel.ShipmentBriefModel
{
Id = shipment.Id,
ShipmentNumber = shipment.ShipmentNumber,
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);
}
}
//billing info
await _addressViewModelService.PrepareModel(model : model.BillingAddress,
address : order.BillingAddress,
excludeProperties : false);
//VAT number
model.VatNumber = order.VatNumber;
//payment method
var paymentMethod = _paymentService.LoadPaymentMethodBySystemName(order.PaymentMethodSystemName);
model.PaymentMethod = paymentMethod != null?paymentMethod.GetLocalizedFriendlyName(_localizationService, _workContext.WorkingLanguage.Id) : order.PaymentMethodSystemName;
model.PaymentMethodStatus = order.PaymentStatus.GetLocalizedEnum(_localizationService, _workContext);
model.CanRePostProcessPayment = await _paymentService.CanRePostProcessPayment(order);
//custom values
model.CustomValues = order.DeserializeCustomValues();
//order subtotal
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal)
{
//including tax
//order subtotal
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
model.OrderSubtotal = await _priceFormatter.FormatPrice(orderSubtotalInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
//discount (applied to order subtotal)
var orderSubTotalDiscountInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountInclTax, order.CurrencyRate);
if (orderSubTotalDiscountInclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = await _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
}
else
{
//excluding tax
//order subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = await _priceFormatter.FormatPrice(orderSubtotalExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
//discount (applied to order subtotal)
var orderSubTotalDiscountExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountExclTax, order.CurrencyRate);
if (orderSubTotalDiscountExclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = await _priceFormatter.FormatPrice(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
}
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
//order shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
model.OrderShipping = await _priceFormatter.FormatShippingPrice(orderShippingInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
//payment method additional fee
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeInclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = await _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
}
else
{
//excluding tax
//order shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = await _priceFormatter.FormatShippingPrice(orderShippingExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
//payment method additional fee
var paymentMethodAdditionalFeeExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeExclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = await _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
}
//tax
bool displayTax = true;
bool 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.Any();
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
//TODO pass languageId to _priceFormatter.FormatPrice
model.Tax = await _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
foreach (var tr in order.TaxRatesDictionary)
{
model.TaxRates.Add(new OrderDetailsModel.TaxRate
{
Rate = _priceFormatter.FormatTaxRate(tr.Key),
//TODO pass languageId to _priceFormatter.FormatPrice
Value = await _priceFormatter.FormatPrice(_currencyService.ConvertCurrency(tr.Value, order.CurrencyRate), true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage),
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
model.DisplayTaxShippingInfo = _catalogSettings.DisplayTaxShippingInfoOrderDetailsPage;
model.PricesIncludeTax = order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax;
//discount (applied to order total)
var orderDiscountInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderDiscount, order.CurrencyRate);
if (orderDiscountInCustomerCurrency > decimal.Zero)
{
model.OrderTotalDiscount = await _priceFormatter.FormatPrice(-orderDiscountInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
}
//gift cards
foreach (var gcuh in await _giftCardService.GetAllGiftCardUsageHistory(order.Id))
{
var giftCard = await _giftCardService.GetGiftCardById(gcuh.GiftCardId);
model.GiftCards.Add(new OrderDetailsModel.GiftCard
{
CouponCode = giftCard.GiftCardCouponCode,
Amount = await _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage),
});
}
//reward points
if (order.RedeemedRewardPointsEntry != null)
{
model.RedeemedRewardPoints = -order.RedeemedRewardPointsEntry.Points;
model.RedeemedRewardPointsAmount = await _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(order.RedeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
}
//total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
model.OrderTotal = await _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
//checkout attributes
model.CheckoutAttributeInfo = order.CheckoutAttributeDescription;
//order notes
foreach (var orderNote in (await _orderService.GetOrderNotes(order.Id))
.Where(on => on.DisplayToCustomer)
.OrderByDescending(on => on.CreatedOnUtc)
.ToList())
{
model.OrderNotes.Add(new OrderDetailsModel.OrderNote
{
Id = orderNote.Id,
OrderId = orderNote.OrderId,
HasDownload = !String.IsNullOrEmpty(orderNote.DownloadId),
Note = orderNote.FormatOrderNoteText(),
CreatedOn = _dateTimeHelper.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc)
});
}
//allow cancel order
if (_orderSettings.UserCanCancelUnpaidOrder)
{
if (order.OrderStatus == OrderStatus.Pending && order.PaymentStatus == Core.Domain.Payments.PaymentStatus.Pending &&
(order.ShippingStatus == ShippingStatus.ShippingNotRequired || order.ShippingStatus == ShippingStatus.NotYetShipped))
{
model.UserCanCancelUnpaidOrder = true;
}
}
//purchased products
model.ShowSku = _catalogSettings.ShowSkuOnProductDetailsPage;
foreach (var orderItem in order.OrderItems)
{
var product = await _productService.GetProductByIdIncludeArch(orderItem.ProductId);
var orderItemModel = new OrderDetailsModel.OrderItemModel
{
Id = orderItem.Id,
OrderItemGuid = orderItem.OrderItemGuid,
Sku = product.FormatSku(orderItem.AttributesXml, _productAttributeParser),
ProductId = product.Id,
ProductName = product.GetLocalized(x => x.Name, _workContext.WorkingLanguage.Id),
ProductSeName = product.SeName,
Quantity = orderItem.Quantity,
AttributeInfo = orderItem.AttributeDescription,
};
model.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.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
orderItemModel.UnitPriceValue = unitPriceInclTaxInCustomerCurrency;
var unitPriceWithDiscInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceWithoutDiscInclTax, order.CurrencyRate);
orderItemModel.UnitPriceWithoutDiscount = await _priceFormatter.FormatPrice(unitPriceWithDiscInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
orderItemModel.UnitPriceWithoutDiscountValue = unitPriceWithDiscInclTaxInCustomerCurrency;
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
orderItemModel.SubTotal = await _priceFormatter.FormatPrice(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
if (orderItem.DiscountAmountInclTax > 0)
{
var discountCustomerCurrency = _currencyService.ConvertCurrency(orderItem.DiscountAmountInclTax, order.CurrencyRate);
orderItemModel.Discount = await _priceFormatter.FormatPrice(discountCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = await _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
orderItemModel.UnitPriceValue = unitPriceExclTaxInCustomerCurrency;
var unitPriceExclWithDiscTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceWithoutDiscExclTax, order.CurrencyRate);
orderItemModel.UnitPriceWithoutDiscount = await _priceFormatter.FormatPrice(unitPriceExclWithDiscTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
orderItemModel.UnitPriceWithoutDiscountValue = unitPriceExclWithDiscTaxInCustomerCurrency;
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
orderItemModel.SubTotal = await _priceFormatter.FormatPrice(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
if (orderItem.DiscountAmountExclTax > 0)
{
var discountCustomerCurrency = _currencyService.ConvertCurrency(orderItem.DiscountAmountExclTax, order.CurrencyRate);
orderItemModel.Discount = await _priceFormatter.FormatPrice(discountCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
}
//downloadable products
if (await _downloadService.IsDownloadAllowed(orderItem))
{
orderItemModel.DownloadId = product.DownloadId;
}
if (await _downloadService.IsLicenseDownloadAllowed(orderItem))
{
orderItemModel.LicenseId = !String.IsNullOrEmpty(orderItem.LicenseDownloadId) ? orderItem.LicenseDownloadId : "";
}
}
return(model);
}
/// <summary>
/// Prepare the order details model
/// </summary>
/// <param name="order">Order</param>
/// <returns>Order details model</returns>
public virtual OrderDetailsModel PrepareOrderDetailsModel(Order order)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
var model = new OrderDetailsModel
{
Id = order.Id,
CreatedOn = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc),
OrderStatus = _localizationService.GetLocalizedEnum(order.OrderStatus),
IsReOrderAllowed = _orderSettings.IsReOrderAllowed,
IsReturnRequestAllowed = _orderProcessingService.IsReturnRequestAllowed(order),
PdfInvoiceDisabled = _pdfSettings.DisablePdfInvoicesForPendingOrders && order.OrderStatus == OrderStatus.Pending,
CustomOrderNumber = order.CustomOrderNumber,
//shipping info
ShippingStatus = _localizationService.GetLocalizedEnum(order.ShippingStatus)
};
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.PickupInStore = order.PickupInStore;
if (!order.PickupInStore)
{
var shippingAddress = _addressService.GetAddressById(order.ShippingAddressId ?? 0);
_addressModelFactory.PrepareAddressModel(model.ShippingAddress,
address: shippingAddress,
excludeProperties: false,
addressSettings: _addressSettings);
}
else if (order.PickupAddressId.HasValue && _addressService.GetAddressById(order.PickupAddressId.Value) is Address pickupAddress)
{
model.PickupAddress = new AddressModel
{
Address1 = pickupAddress.Address1,
City = pickupAddress.City,
County = pickupAddress.County,
CountryName = _countryService.GetCountryByAddress(pickupAddress)?.Name ?? string.Empty,
ZipPostalCode = pickupAddress.ZipPostalCode
};
}
model.ShippingMethod = order.ShippingMethod;
//shipments (only already shipped)
var shipments = _shipmentService.GetShipmentsByOrderId(order.Id, true).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);
}
}
var billingAddress = _addressService.GetAddressById(order.BillingAddressId);
//billing info
_addressModelFactory.PrepareAddressModel(model.BillingAddress,
address: billingAddress,
excludeProperties: false,
addressSettings: _addressSettings);
//VAT number
model.VatNumber = order.VatNumber;
var languageId = _workContext.WorkingLanguage.Id;
//payment method
var customer = _customerService.GetCustomerById(order.CustomerId);
var paymentMethod = _paymentPluginManager
.LoadPluginBySystemName(order.PaymentMethodSystemName, customer, order.StoreId);
model.PaymentMethod = paymentMethod != null?_localizationService.GetLocalizedFriendlyName(paymentMethod, languageId) : order.PaymentMethodSystemName;
model.PaymentMethodStatus = _localizationService.GetLocalizedEnum(order.PaymentStatus);
model.CanRePostProcessPayment = _paymentService.CanRePostProcessPayment(order);
//custom values
model.CustomValues = _paymentService.DeserializeCustomValues(order);
//order subtotal
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal)
{
//including tax
//order subtotal
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
model.OrderSubtotal = _priceFormatter.FormatPrice(orderSubtotalInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
//discount (applied to order subtotal)
var orderSubTotalDiscountInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountInclTax, order.CurrencyRate);
if (orderSubTotalDiscountInclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
}
}
else
{
//excluding tax
//order subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = _priceFormatter.FormatPrice(orderSubtotalExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
//discount (applied to order subtotal)
var orderSubTotalDiscountExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountExclTax, order.CurrencyRate);
if (orderSubTotalDiscountExclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
}
}
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
//order shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
model.OrderShipping = _priceFormatter.FormatShippingPrice(orderShippingInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
//payment method additional fee
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeInclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
}
}
else
{
//excluding tax
//order shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = _priceFormatter.FormatShippingPrice(orderShippingExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
//payment method additional fee
var paymentMethodAdditionalFeeExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeExclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
}
}
//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
{
var taxRates = _orderService.ParseTaxRates(order, order.TaxRates);
displayTaxRates = _taxSettings.DisplayTaxRates && taxRates.Any();
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
model.Tax = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
foreach (var tr in taxRates)
{
model.TaxRates.Add(new OrderDetailsModel.TaxRate
{
Rate = _priceFormatter.FormatTaxRate(tr.Key),
Value = _priceFormatter.FormatPrice(_currencyService.ConvertCurrency(tr.Value, order.CurrencyRate), true, order.CustomerCurrencyCode, false, languageId),
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
model.DisplayTaxShippingInfo = _catalogSettings.DisplayTaxShippingInfoOrderDetailsPage;
model.PricesIncludeTax = order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax;
//discount (applied to order total)
var orderDiscountInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderDiscount, order.CurrencyRate);
if (orderDiscountInCustomerCurrency > decimal.Zero)
{
model.OrderTotalDiscount = _priceFormatter.FormatPrice(-orderDiscountInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
}
//gift cards
foreach (var gcuh in _giftCardService.GetGiftCardUsageHistory(order))
{
model.GiftCards.Add(new OrderDetailsModel.GiftCard
{
CouponCode = _giftCardService.GetGiftCardById(gcuh.GiftCardId).GiftCardCouponCode,
Amount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, languageId),
});
}
//reward points
if (order.RedeemedRewardPointsEntryId.HasValue && _rewardPointService.GetRewardPointsHistoryEntryById(order.RedeemedRewardPointsEntryId.Value) is RewardPointsHistory redeemedRewardPointsEntry)
{
model.RedeemedRewardPoints = -redeemedRewardPointsEntry.Points;
model.RedeemedRewardPointsAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(redeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, languageId);
}
//total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
model.OrderTotal = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
//checkout attributes
model.CheckoutAttributeInfo = order.CheckoutAttributeDescription;
//order notes
foreach (var orderNote in _orderService.GetOrderNotesByOrderId(order.Id, true)
.OrderByDescending(on => on.CreatedOnUtc)
.ToList())
{
model.OrderNotes.Add(new OrderDetailsModel.OrderNote
{
Id = orderNote.Id,
HasDownload = orderNote.DownloadId > 0,
Note = _orderService.FormatOrderNoteText(orderNote),
CreatedOn = _dateTimeHelper.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc)
});
}
//purchased products
model.ShowSku = _catalogSettings.ShowSkuOnProductDetailsPage;
model.ShowVendorName = _vendorSettings.ShowVendorOnOrderDetailsPage;
var orderItems = _orderService.GetOrderItems(order.Id);
foreach (var orderItem in orderItems)
{
var product = _productService.GetProductById(orderItem.ProductId);
var orderItemModel = new OrderDetailsModel.OrderItemModel
{
Id = orderItem.Id,
OrderItemGuid = orderItem.OrderItemGuid,
Sku = _productService.FormatSku(product, orderItem.AttributesXml),
VendorName = _vendorService.GetVendorById(product.VendorId)?.Name ?? string.Empty,
ProductId = product.Id,
ProductName = _localizationService.GetLocalized(product, x => x.Name),
ProductSeName = _urlRecordService.GetSeName(product),
Quantity = orderItem.Quantity,
AttributeInfo = orderItem.AttributeDescription,
};
//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(_localizationService.GetResource("Order.Rental.FormattedDate"),
rentalStartDate, rentalEndDate);
}
model.Items.Add(orderItemModel);
//unit price, subtotal
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
}
//downloadable products
if (_orderService.IsDownloadAllowed(orderItem))
{
orderItemModel.DownloadId = product.DownloadId;
}
if (_orderService.IsLicenseDownloadAllowed(orderItem))
{
orderItemModel.LicenseId = orderItem.LicenseDownloadId ?? 0;
}
}
return(model);
}