private async Task PrepareShippingInfo(GetOrderDetails request, OrderDetailsModel model)
{
model.ShippingStatus = request.Order.ShippingStatusId.GetTranslationEnum(_translationService, request.Language.Id);
if (request.Order.ShippingStatusId != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.PickUpInStore = request.Order.PickUpInStore;
if (!request.Order.PickUpInStore)
{
model.ShippingAddress = await _mediator.Send(new GetAddressModel()
{
Language = request.Language,
Model = null,
Address = request.Order.ShippingAddress,
ExcludeProperties = false,
});
}
else
{
if (request.Order.PickupPoint != null)
{
if (request.Order.PickupPoint.Address != null)
{
model.PickupAddress = await _mediator.Send(new GetAddressModel()
{
Language = request.Language,
Address = request.Order.PickupPoint.Address,
ExcludeProperties = false,
});
}
}
}
model.ShippingMethod = request.Order.ShippingMethod;
model.ShippingAdditionDescription = request.Order.ShippingOptionAttributeDescription;
//shipments (only already shipped)
var shipments = (await _shipmentService.GetShipmentsByOrder(request.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 = _dateTimeService.ConvertToUserTime(shipment.ShippedDateUtc.Value, DateTimeKind.Utc);
}
if (shipment.DeliveryDateUtc.HasValue)
{
shipmentModel.DeliveryDate = _dateTimeService.ConvertToUserTime(shipment.DeliveryDateUtc.Value, DateTimeKind.Utc);
}
model.Shipments.Add(shipmentModel);
}
}
}
protected virtual OrderDetailsModel PrepareOrderDetailsModel(Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
var model = new OrderDetailsModel();
model.Id = order.Id;
model.CreatedOn = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc);
model.OrderStatus = order.OrderStatus.GetLocalizedEnum(_localizationService, _workContext);
model.IsReOrderAllowed = _orderSettings.IsReOrderAllowed;
model.IsReturnRequestAllowed = _orderProcessingService.IsReturnRequestAllowed(order);
//shipping info
model.ShippingStatus = order.ShippingStatus.GetLocalizedEnum(_localizationService, _workContext);
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.PickUpInStore = order.PickUpInStore;
if (!order.PickUpInStore)
{
model.ShippingAddress.PrepareModel(
address: order.ShippingAddress,
excludeProperties: false,
addressSettings: _addressSettings,
addressAttributeFormatter: _addressAttributeFormatter);
}
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);
}
}
//billing info
model.BillingAddress.PrepareModel(
address: order.BillingAddress,
excludeProperties: false,
addressSettings: _addressSettings,
addressAttributeFormatter: _addressAttributeFormatter);
//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 = _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 = _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 = _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
}
else
{
//excluding tax
//order subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = _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 = _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 = _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 = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
}
else
{
//excluding tax
//order shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = _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 = _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.Count > 0;
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
//TODO pass languageId to _priceFormatter.FormatPrice
model.Tax = _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 = _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 = _priceFormatter.FormatPrice(-orderDiscountInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
}
//gift cards
foreach (var gcuh in order.GiftCardUsageHistory)
{
model.GiftCards.Add(new OrderDetailsModel.GiftCard
{
CouponCode = gcuh.GiftCard.GiftCardCouponCode,
Amount = _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 = _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 = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
//checkout attributes
model.CheckoutAttributeInfo = order.CheckoutAttributeDescription;
//order notes
foreach (var orderNote in order.OrderNotes
.Where(on => on.DisplayToCustomer)
.OrderByDescending(on => on.CreatedOnUtc)
.ToList())
{
model.OrderNotes.Add(new OrderDetailsModel.OrderNote
{
Id = orderNote.Id,
HasDownload = orderNote.DownloadId > 0,
Note = orderNote.FormatOrderNoteText(),
CreatedOn = _dateTimeHelper.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc)
});
}
//purchased products
model.ShowSku = _catalogSettings.ShowProductSku;
var orderItems = _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
var orderItemModel = new OrderDetailsModel.OrderItemModel
{
Id = orderItem.Id,
OrderItemGuid = orderItem.OrderItemGuid,
Sku = orderItem.Product.FormatSku(orderItem.AttributesXml, _productAttributeParser),
ProductId = orderItem.Product.Id,
ProductName = orderItem.Product.GetLocalized(x => x.Name),
ProductSeName = orderItem.Product.GetSeName(),
Quantity = orderItem.Quantity,
AttributeInfo = orderItem.AttributeDescription,
};
//rental info
if (orderItem.Product.IsRental)
{
var rentalStartDate = orderItem.RentalStartDateUtc.HasValue ? orderItem.Product.FormatRentalDate(orderItem.RentalStartDateUtc.Value) : "";
var rentalEndDate = orderItem.RentalEndDateUtc.HasValue ? orderItem.Product.FormatRentalDate(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, _workContext.WorkingLanguage, true);
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
//downloadable products
if (_downloadService.IsDownloadAllowed(orderItem))
{
orderItemModel.DownloadId = orderItem.Product.DownloadId;
}
if (_downloadService.IsLicenseDownloadAllowed(orderItem))
{
orderItemModel.LicenseId = orderItem.LicenseDownloadId.HasValue ? orderItem.LicenseDownloadId.Value : 0;
}
}
return(model);
}
protected OrderDetailsModel PrepareOrderDetailsModel(Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
var model = new OrderDetailsModel();
model.Id = order.Id;
model.CreatedOn = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc);
model.OrderStatus = order.OrderStatus.GetLocalizedEnum(_localizationService, _workContext);
model.IsReOrderAllowed = _orderSettings.IsReOrderAllowed;
model.IsReturnRequestAllowed = _orderProcessingService.IsReturnRequestAllowed(order);
model.DisplayPdfInvoice = _pdfSettings.Enabled;
//shipping info
model.ShippingStatus = order.ShippingStatus.GetLocalizedEnum(_localizationService, _workContext);
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.ShippingAddress = order.ShippingAddress.ToModel();
model.ShippingMethod = order.ShippingMethod;
model.OrderWeight = order.OrderWeight;
var baseWeight = _measureService.GetMeasureWeightById(_measureSettings.BaseWeightId);
if (baseWeight != null)
{
model.BaseWeightIn = baseWeight.Name;
}
//shipments
var shipments = order.Shipments.OrderBy(x => x.ShippedDateUtc).ToList();
foreach (var shipment in shipments)
{
var shipmentModel = new OrderDetailsModel.ShipmentBriefModel()
{
Id = shipment.Id,
TrackingNumber = shipment.TrackingNumber,
ShippedDate = _dateTimeHelper.ConvertToUserTime(shipment.ShippedDateUtc, DateTimeKind.Utc),
};
if (shipment.DeliveryDateUtc.HasValue)
{
shipmentModel.DeliveryDate = _dateTimeHelper.ConvertToUserTime(shipment.DeliveryDateUtc.Value, DateTimeKind.Utc);
}
model.Shipments.Add(shipmentModel);
}
}
//billing info
model.BillingAddress = order.BillingAddress.ToModel();
//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.CanRePostProcessPayment = _paymentService.CanRePostProcessPayment(order);
//totals)
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
//order subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = _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 = _priceFormatter.FormatPrice(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
//order shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = _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 = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
}
break;
case TaxDisplayType.IncludingTax:
{
//order subtotal
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
model.OrderSubtotal = _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 = _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
//order shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
model.OrderShipping = _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 = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
}
break;
}
//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.Count > 0;
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
//TODO pass languageId to _priceFormatter.FormatPrice
model.Tax = _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 = _priceFormatter.FormatPrice(_currencyService.ConvertCurrency(tr.Value, order.CurrencyRate), true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage),
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
//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, _workContext.WorkingLanguage);
}
//gift cards
foreach (var gcuh in order.GiftCardUsageHistory)
{
model.GiftCards.Add(new OrderDetailsModel.GiftCard()
{
CouponCode = gcuh.GiftCard.GiftCardCouponCode,
Amount = _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 = _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 = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
//checkout attributes
model.CheckoutAttributeInfo = order.CheckoutAttributeDescription;
//order notes
foreach (var orderNote in order.OrderNotes
.Where(on => on.DisplayToCustomer)
.OrderByDescending(on => on.CreatedOnUtc)
.ToList())
{
model.OrderNotes.Add(new OrderDetailsModel.OrderNote()
{
Note = orderNote.FormatOrderNoteText(),
CreatedOn = _dateTimeHelper.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc)
});
}
//purchased products
model.ShowSku = _catalogSettings.ShowProductSku;
var orderProductVariants = _orderService.GetAllOrderProductVariants(order.Id, null, null, null, null, null, null);
foreach (var opv in orderProductVariants)
{
var opvModel = new OrderDetailsModel.OrderProductVariantModel()
{
Id = opv.Id,
Sku = opv.ProductVariant.Sku,
ProductId = opv.ProductVariant.ProductId,
ProductSeName = opv.ProductVariant.Product.GetSeName(),
Quantity = opv.Quantity,
AttributeInfo = opv.AttributeDescription,
};
//product name
if (!String.IsNullOrEmpty(opv.ProductVariant.GetLocalized(x => x.Name)))
{
opvModel.ProductName = string.Format("{0} ({1})", opv.ProductVariant.Product.GetLocalized(x => x.Name), opv.ProductVariant.GetLocalized(x => x.Name));
}
else
{
opvModel.ProductName = opv.ProductVariant.Product.GetLocalized(x => x.Name);
}
model.Items.Add(opvModel);
//unit price, subtotal
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var opvUnitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(opv.UnitPriceExclTax, order.CurrencyRate);
opvModel.UnitPrice = _priceFormatter.FormatPrice(opvUnitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
var opvPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(opv.PriceExclTax, order.CurrencyRate);
opvModel.SubTotal = _priceFormatter.FormatPrice(opvPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var opvUnitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(opv.UnitPriceInclTax, order.CurrencyRate);
opvModel.UnitPrice = _priceFormatter.FormatPrice(opvUnitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
var opvPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(opv.PriceInclTax, order.CurrencyRate);
opvModel.SubTotal = _priceFormatter.FormatPrice(opvPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
break;
}
}
return(model);
}
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>
/// A task that represents the asynchronous operation
/// The task result contains the order details model
/// </returns>
public virtual async Task <OrderDetailsModel> PrepareOrderDetailsModelAsync(Order order)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
var model = new OrderDetailsModel
{
Id = order.Id,
CreatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(order.CreatedOnUtc, DateTimeKind.Utc),
OrderStatus = await _localizationService.GetLocalizedEnumAsync(order.OrderStatus),
IsReOrderAllowed = _orderSettings.IsReOrderAllowed,
IsReturnRequestAllowed = await _orderProcessingService.IsReturnRequestAllowedAsync(order),
PdfInvoiceDisabled = _pdfSettings.DisablePdfInvoicesForPendingOrders && order.OrderStatus == OrderStatus.Pending,
CustomOrderNumber = order.CustomOrderNumber,
//shipping info
ShippingStatus = await _localizationService.GetLocalizedEnumAsync(order.ShippingStatus)
};
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.PickupInStore = order.PickupInStore;
if (!order.PickupInStore)
{
var shippingAddress = await _addressService.GetAddressByIdAsync(order.ShippingAddressId ?? 0);
await _addressModelFactory.PrepareAddressModelAsync(model.ShippingAddress,
address : shippingAddress,
excludeProperties : false,
addressSettings : _addressSettings);
}
else if (order.PickupAddressId.HasValue && await _addressService.GetAddressByIdAsync(order.PickupAddressId.Value) is Address pickupAddress)
{
model.PickupAddress = new AddressModel
{
Address1 = pickupAddress.Address1,
City = pickupAddress.City,
County = pickupAddress.County,
StateProvinceName = await _stateProvinceService.GetStateProvinceByAddressAsync(pickupAddress) is StateProvince stateProvince
? await _localizationService.GetLocalizedAsync(stateProvince, entity => entity.Name)
: string.Empty,
CountryName = await _countryService.GetCountryByAddressAsync(pickupAddress) is Country country
? await _localizationService.GetLocalizedAsync(country, entity => entity.Name)
: string.Empty,
ZipPostalCode = pickupAddress.ZipPostalCode
};
}
model.ShippingMethod = order.ShippingMethod;
//shipments (only already shipped or ready for pickup)
var shipments = (await _shipmentService.GetShipmentsByOrderIdAsync(order.Id, !order.PickupInStore, order.PickupInStore)).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 = await _dateTimeHelper.ConvertToUserTimeAsync(shipment.ShippedDateUtc.Value, DateTimeKind.Utc);
}
if (shipment.ReadyForPickupDateUtc.HasValue)
{
shipmentModel.ReadyForPickupDate = await _dateTimeHelper.ConvertToUserTimeAsync(shipment.ReadyForPickupDateUtc.Value, DateTimeKind.Utc);
}
if (shipment.DeliveryDateUtc.HasValue)
{
shipmentModel.DeliveryDate = await _dateTimeHelper.ConvertToUserTimeAsync(shipment.DeliveryDateUtc.Value, DateTimeKind.Utc);
}
model.Shipments.Add(shipmentModel);
}
}
var billingAddress = await _addressService.GetAddressByIdAsync(order.BillingAddressId);
//billing info
await _addressModelFactory.PrepareAddressModelAsync(model.BillingAddress,
address : billingAddress,
excludeProperties : false,
addressSettings : _addressSettings);
//VAT number
model.VatNumber = order.VatNumber;
var languageId = (await _workContext.GetWorkingLanguageAsync()).Id;
//payment method
var customer = await _customerService.GetCustomerByIdAsync(order.CustomerId);
var paymentMethod = await _paymentPluginManager
.LoadPluginBySystemNameAsync(order.PaymentMethodSystemName, customer, order.StoreId);
model.PaymentMethod = paymentMethod != null ? await _localizationService.GetLocalizedFriendlyNameAsync(paymentMethod, languageId) : order.PaymentMethodSystemName;
model.PaymentMethodStatus = await _localizationService.GetLocalizedEnumAsync(order.PaymentStatus);
model.CanRePostProcessPayment = await _paymentService.CanRePostProcessPaymentAsync(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 = await _priceFormatter.FormatPriceAsync(orderSubtotalInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
model.OrderSubtotalValue = orderSubtotalInclTaxInCustomerCurrency;
//discount (applied to order subtotal)
var orderSubTotalDiscountInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountInclTax, order.CurrencyRate);
if (orderSubTotalDiscountInclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = await _priceFormatter.FormatPriceAsync(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
model.OrderSubTotalDiscountValue = orderSubTotalDiscountInclTaxInCustomerCurrency;
}
}
else
{
//excluding tax
//order subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = await _priceFormatter.FormatPriceAsync(orderSubtotalExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
model.OrderSubtotalValue = orderSubtotalExclTaxInCustomerCurrency;
//discount (applied to order subtotal)
var orderSubTotalDiscountExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountExclTax, order.CurrencyRate);
if (orderSubTotalDiscountExclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = await _priceFormatter.FormatPriceAsync(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
model.OrderSubTotalDiscountValue = orderSubTotalDiscountExclTaxInCustomerCurrency;
}
}
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
//order shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
model.OrderShipping = await _priceFormatter.FormatShippingPriceAsync(orderShippingInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
model.OrderShippingValue = orderShippingInclTaxInCustomerCurrency;
//payment method additional fee
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeInclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = await _priceFormatter.FormatPaymentMethodAdditionalFeeAsync(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
model.PaymentMethodAdditionalFeeValue = paymentMethodAdditionalFeeInclTaxInCustomerCurrency;
}
}
else
{
//excluding tax
//order shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = await _priceFormatter.FormatShippingPriceAsync(orderShippingExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
model.OrderShippingValue = orderShippingExclTaxInCustomerCurrency;
//payment method additional fee
var paymentMethodAdditionalFeeExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeExclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = await _priceFormatter.FormatPaymentMethodAdditionalFeeAsync(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
model.PaymentMethodAdditionalFeeValue = paymentMethodAdditionalFeeExclTaxInCustomerCurrency;
}
}
//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 = await _priceFormatter.FormatPriceAsync(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
foreach (var tr in taxRates)
{
model.TaxRates.Add(new OrderDetailsModel.TaxRate
{
Rate = _priceFormatter.FormatTaxRate(tr.Key),
Value = await _priceFormatter.FormatPriceAsync(_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 = await _priceFormatter.FormatPriceAsync(-orderDiscountInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
model.OrderTotalDiscountValue = orderDiscountInCustomerCurrency;
}
//gift cards
foreach (var gcuh in await _giftCardService.GetGiftCardUsageHistoryAsync(order))
{
model.GiftCards.Add(new OrderDetailsModel.GiftCard
{
CouponCode = (await _giftCardService.GetGiftCardByIdAsync(gcuh.GiftCardId)).GiftCardCouponCode,
Amount = await _priceFormatter.FormatPriceAsync(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, languageId),
});
}
//reward points
if (order.RedeemedRewardPointsEntryId.HasValue && await _rewardPointService.GetRewardPointsHistoryEntryByIdAsync(order.RedeemedRewardPointsEntryId.Value) is RewardPointsHistory redeemedRewardPointsEntry)
{
model.RedeemedRewardPoints = -redeemedRewardPointsEntry.Points;
model.RedeemedRewardPointsAmount = await _priceFormatter.FormatPriceAsync(-(_currencyService.ConvertCurrency(redeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, languageId);
}
//total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
model.OrderTotal = await _priceFormatter.FormatPriceAsync(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
model.OrderTotalValue = orderTotalInCustomerCurrency;
//checkout attributes
model.CheckoutAttributeInfo = order.CheckoutAttributeDescription;
//order notes
foreach (var orderNote in (await _orderService.GetOrderNotesByOrderIdAsync(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 = await _dateTimeHelper.ConvertToUserTimeAsync(orderNote.CreatedOnUtc, DateTimeKind.Utc)
});
}
//purchased products
model.ShowSku = _catalogSettings.ShowSkuOnProductDetailsPage;
model.ShowVendorName = _vendorSettings.ShowVendorOnOrderDetailsPage;
var orderItems = await _orderService.GetOrderItemsAsync(order.Id);
foreach (var orderItem in orderItems)
{
var product = await _productService.GetProductByIdAsync(orderItem.ProductId);
var orderItemModel = new OrderDetailsModel.OrderItemModel
{
Id = orderItem.Id,
OrderItemGuid = orderItem.OrderItemGuid,
Sku = await _productService.FormatSkuAsync(product, orderItem.AttributesXml),
VendorName = (await _vendorService.GetVendorByIdAsync(product.VendorId))?.Name ?? string.Empty,
ProductId = product.Id,
ProductName = await _localizationService.GetLocalizedAsync(product, x => x.Name),
ProductSeName = await _urlRecordService.GetSeNameAsync(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(await _localizationService.GetResourceAsync("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 = await _priceFormatter.FormatPriceAsync(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
orderItemModel.UnitPriceValue = unitPriceInclTaxInCustomerCurrency;
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
orderItemModel.SubTotal = await _priceFormatter.FormatPriceAsync(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
orderItemModel.SubTotalValue = priceInclTaxInCustomerCurrency;
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = await _priceFormatter.FormatPriceAsync(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
orderItemModel.UnitPriceValue = unitPriceExclTaxInCustomerCurrency;
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
orderItemModel.SubTotal = await _priceFormatter.FormatPriceAsync(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
orderItemModel.SubTotalValue = priceExclTaxInCustomerCurrency;
}
//downloadable products
if (await _orderService.IsDownloadAllowedAsync(orderItem))
{
orderItemModel.DownloadId = product.DownloadId;
}
if (await _orderService.IsLicenseDownloadAllowedAsync(orderItem))
{
orderItemModel.LicenseId = orderItem.LicenseDownloadId ?? 0;
}
}
return(model);
}
public OrderDetailsModel PrepareOrderDetailsModel(Order order)
{
Guard.NotNull(order, nameof(order));
var store = _services.StoreService.GetStoreById(order.StoreId) ?? _services.StoreContext.CurrentStore;
var language = _services.WorkContext.WorkingLanguage;
var orderSettings = _services.Settings.LoadSetting <OrderSettings>(store.Id);
var catalogSettings = _services.Settings.LoadSetting <CatalogSettings>(store.Id);
var taxSettings = _services.Settings.LoadSetting <TaxSettings>(store.Id);
var pdfSettings = _services.Settings.LoadSetting <PdfSettings>(store.Id);
var addressSettings = _services.Settings.LoadSetting <AddressSettings>(store.Id);
var companyInfoSettings = _services.Settings.LoadSetting <CompanyInformationSettings>(store.Id);
var shoppingCartSettings = _services.Settings.LoadSetting <ShoppingCartSettings>(store.Id);
var mediaSettings = _services.Settings.LoadSetting <MediaSettings>(store.Id);
var model = new OrderDetailsModel();
model.MerchantCompanyInfo = companyInfoSettings;
model.Id = order.Id;
model.StoreId = order.StoreId;
model.CustomerLanguageId = order.CustomerLanguageId;
model.CustomerComment = order.CustomerOrderComment;
model.OrderNumber = order.GetOrderNumber();
model.CreatedOn = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc);
model.OrderStatus = order.OrderStatus.GetLocalizedEnum(_services.Localization, _services.WorkContext);
model.IsReOrderAllowed = orderSettings.IsReOrderAllowed;
model.IsReturnRequestAllowed = _orderProcessingService.IsReturnRequestAllowed(order);
model.DisplayPdfInvoice = pdfSettings.Enabled;
model.RenderOrderNotes = pdfSettings.RenderOrderNotes;
// Shipping info.
model.ShippingStatus = order.ShippingStatus.GetLocalizedEnum(_services.Localization, _services.WorkContext);
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.ShippingAddress.PrepareModel(order.ShippingAddress, false, addressSettings);
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);
}
}
model.BillingAddress.PrepareModel(order.BillingAddress, false, addressSettings);
model.VatNumber = order.VatNumber;
// Payment method.
var paymentMethod = _paymentService.LoadPaymentMethodBySystemName(order.PaymentMethodSystemName);
model.PaymentMethod = paymentMethod != null?_pluginMediator.GetLocalizedFriendlyName(paymentMethod.Metadata) : order.PaymentMethodSystemName;
model.CanRePostProcessPayment = _paymentService.CanRePostProcessPayment(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;
}
// Totals.
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
// Order subtotal.
var orderSubtotalExclTax = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = _priceFormatter.FormatPrice(orderSubtotalExclTax, true, order.CustomerCurrencyCode, language, false, false);
// Discount (applied to order subtotal).
var orderSubTotalDiscountExclTax = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountExclTax, order.CurrencyRate);
if (orderSubTotalDiscountExclTax > decimal.Zero)
{
model.OrderSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountExclTax, true, order.CustomerCurrencyCode, language, false, false);
}
// Order shipping.
var orderShippingExclTax = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = _priceFormatter.FormatShippingPrice(orderShippingExclTax, true, order.CustomerCurrencyCode, language, false, false);
// Payment method additional fee.
var paymentMethodAdditionalFeeExclTax = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeExclTax != decimal.Zero)
{
model.PaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTax, true, order.CustomerCurrencyCode,
language, false, false);
}
}
break;
case TaxDisplayType.IncludingTax:
{
// Order subtotal.
var orderSubtotalInclTax = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
model.OrderSubtotal = _priceFormatter.FormatPrice(orderSubtotalInclTax, true, order.CustomerCurrencyCode, language, true, false);
// Discount (applied to order subtotal).
var orderSubTotalDiscountInclTax = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountInclTax, order.CurrencyRate);
if (orderSubTotalDiscountInclTax > decimal.Zero)
{
model.OrderSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTax, true, order.CustomerCurrencyCode, language, true, false);
}
// Order shipping.
var orderShippingInclTax = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
model.OrderShipping = _priceFormatter.FormatShippingPrice(orderShippingInclTax, true, order.CustomerCurrencyCode, language, true, false);
// Payment method additional fee.
var paymentMethodAdditionalFeeInclTax = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeInclTax != decimal.Zero)
{
model.PaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTax, true, order.CustomerCurrencyCode,
language, true, false);
}
}
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.ConvertCurrency(order.OrderTax, order.CurrencyRate);
model.Tax = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, false, language);
foreach (var tr in order.TaxRatesDictionary)
{
var rate = _priceFormatter.FormatTaxRate(tr.Key);
//var labelKey = "ShoppingCart.Totals.TaxRateLine" + (_services.WorkContext.TaxDisplayType == TaxDisplayType.IncludingTax ? "Incl" : "Excl");
var labelKey = (_services.WorkContext.TaxDisplayType == TaxDisplayType.IncludingTax ? "ShoppingCart.Totals.TaxRateLineIncl" : "ShoppingCart.Totals.TaxRateLineExcl");
model.TaxRates.Add(new OrderDetailsModel.TaxRate
{
Rate = rate,
Label = T(labelKey).Text.FormatCurrent(rate),
Value = _priceFormatter.FormatPrice(_currencyService.ConvertCurrency(tr.Value, order.CurrencyRate), true, order.CustomerCurrencyCode, false, language),
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
// 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, language);
}
// Gift cards.
foreach (var gcuh in order.GiftCardUsageHistory)
{
var remainingAmountBase = gcuh.GiftCard.GetGiftCardRemainingAmount();
var remainingAmount = _currencyService.ConvertCurrency(remainingAmountBase, order.CurrencyRate);
var gcModel = new OrderDetailsModel.GiftCard
{
CouponCode = gcuh.GiftCard.GiftCardCouponCode,
Amount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, language),
Remaining = _priceFormatter.FormatPrice(remainingAmount, true, false)
};
model.GiftCards.Add(gcModel);
}
// Reward points .
if (order.RedeemedRewardPointsEntry != null)
{
model.RedeemedRewardPoints = -order.RedeemedRewardPointsEntry.Points;
model.RedeemedRewardPointsAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(order.RedeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)),
true, order.CustomerCurrencyCode, false, language);
}
// Credit balance.
if (order.CreditBalance > decimal.Zero)
{
var convertedCreditBalance = _currencyService.ConvertCurrency(order.CreditBalance, order.CurrencyRate);
model.CreditBalance = _priceFormatter.FormatPrice(-convertedCreditBalance, true, order.CustomerCurrencyCode, false, language);
}
// Total.
var roundingAmount = decimal.Zero;
var orderTotal = order.GetOrderTotalInCustomerCurrency(_currencyService, _paymentService, out roundingAmount);
model.OrderTotal = _priceFormatter.FormatPrice(orderTotal, true, order.CustomerCurrencyCode, false, language);
if (roundingAmount != decimal.Zero)
{
model.OrderTotalRounding = _priceFormatter.FormatPrice(roundingAmount, true, order.CustomerCurrencyCode, false, language);
}
// Checkout attributes.
model.CheckoutAttributeInfo = HtmlUtils.ConvertPlainTextToTable(HtmlUtils.ConvertHtmlToPlainText(order.CheckoutAttributeDescription));
// Order notes.
foreach (var orderNote in order.OrderNotes
.Where(on => on.DisplayToCustomer)
.OrderByDescending(on => on.CreatedOnUtc)
.ToList())
{
var createdOn = _dateTimeHelper.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc);
model.OrderNotes.Add(new OrderDetailsModel.OrderNote
{
Note = orderNote.FormatOrderNoteText(),
CreatedOn = createdOn,
FriendlyCreatedOn = createdOn.RelativeFormat(false, "f")
});
}
// Purchased products.
model.ShowSku = catalogSettings.ShowProductSku;
model.ShowProductImages = shoppingCartSettings.ShowProductImagesOnShoppingCart;
model.ShowProductBundleImages = shoppingCartSettings.ShowProductBundleImagesOnShoppingCart;
model.BundleThumbSize = mediaSettings.CartThumbBundleItemPictureSize;
var orderItems = _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
var orderItemModel = PrepareOrderItemModel(
order,
orderItem,
catalogSettings,
shoppingCartSettings,
mediaSettings);
model.Items.Add(orderItemModel);
}
return(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);
}
protected OrderDetailsModel PrepareOrderDetailsModel(Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
var model = new OrderDetailsModel();
model.Id = order.Id;
model.CreatedOn = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc);
model.OrderStatus = order.OrderStatus.GetLocalizedEnum(_localizationService, _workContext);
model.IsReOrderAllowed = _orderSettings.IsReOrderAllowed;
model.IsReturnRequestAllowed = _orderProcessingService.IsReturnRequestAllowed(order);
//shipping info
model.ShippingStatus = order.ShippingStatus.GetLocalizedEnum(_localizationService, _workContext);
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.ShippingAddress.PrepareModel(order.ShippingAddress, false, _addressSettings);
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);
}
}
//billing info
model.BillingAddress.PrepareModel(order.BillingAddress, false, _addressSettings);
//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.CanRePostProcessPayment = _paymentService.CanRePostProcessPayment(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.PluginDescriptor.SystemName.Equals("Payments.PurchaseOrder", StringComparison.InvariantCultureIgnoreCase))
{
model.DisplayPurchaseOrderNumber = true;
model.PurchaseOrderNumber = order.PurchaseOrderNumber;
}
//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, _workContext.WorkingLanguage, 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, _workContext.WorkingLanguage, true);
}
}
else
{
//excluding tax
//order subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = _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 = _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 = _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 = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
}
else
{
//excluding tax
//order shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = _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 = _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.Count > 0;
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
//TODO pass languageId to _priceFormatter.FormatPrice
model.Tax = _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 = _priceFormatter.FormatPrice(_currencyService.ConvertCurrency(tr.Value, order.CurrencyRate), true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage),
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
//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, _workContext.WorkingLanguage);
}
//gift cards
foreach (var gcuh in order.GiftCardUsageHistory)
{
model.GiftCards.Add(new OrderDetailsModel.GiftCard()
{
CouponCode = gcuh.GiftCard.GiftCardCouponCode,
Amount = _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 = _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 = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
//checkout attributes
model.CheckoutAttributeInfo = order.CheckoutAttributeDescription;
//order notes
foreach (var orderNote in order.OrderNotes
.Where(on => on.DisplayToCustomer)
.OrderByDescending(on => on.CreatedOnUtc)
.ToList())
{
model.OrderNotes.Add(new OrderDetailsModel.OrderNote()
{
Id = orderNote.Id,
HasDownload = orderNote.DownloadId > 0,
Note = orderNote.FormatOrderNoteText(),
CreatedOn = _dateTimeHelper.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc)
});
}
//purchased products
model.ShowSku = _catalogSettings.ShowProductSku;
var orderItems = _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
string imgUrl = string.Empty;
if (orderItem.Product.ProductPictures.Count > 0)
{
var picture = orderItem.Product.ProductPictures.FirstOrDefault();
imgUrl = _pictureService.GetPictureUrl(picture.PictureId);
}
var orderItemModel = new OrderDetailsModel.OrderItemModel()
{
Id = orderItem.Id,
Sku = orderItem.Product.FormatSku(orderItem.AttributesXml, _productAttributeParser),
ProductId = orderItem.Product.Id,
ProductName = orderItem.Product.GetLocalized(x => x.Name),
ProductSeName = orderItem.Product.GetSeName(),
Quantity = orderItem.Quantity,
AttributeInfo = orderItem.AttributeDescription,
ProductImageUrl = imgUrl
};
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, _workContext.WorkingLanguage, true);
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
}
return(model);
}
protected OrderDetailsModel PrepareOrderDetailsModel(Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
var store = _storeService.GetStoreById(order.StoreId) ?? _services.StoreContext.CurrentStore;
var orderSettings = _services.Settings.LoadSetting <OrderSettings>(store.Id);
var catalogSettings = _services.Settings.LoadSetting <CatalogSettings>(store.Id);
var taxSettings = _services.Settings.LoadSetting <TaxSettings>(store.Id);
var pdfSettings = _services.Settings.LoadSetting <PdfSettings>(store.Id);
var addressSettings = _services.Settings.LoadSetting <AddressSettings>(store.Id);
var companyInfoSettings = _services.Settings.LoadSetting <CompanyInformationSettings>(store.Id);
var model = new OrderDetailsModel();
model.MerchantCompanyInfo = companyInfoSettings;
model.Id = order.Id;
model.StoreId = order.StoreId;
model.OrderNumber = order.GetOrderNumber();
model.CreatedOn = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc);
model.OrderStatus = order.OrderStatus.GetLocalizedEnum(_services.Localization, _services.WorkContext);
model.IsReOrderAllowed = orderSettings.IsReOrderAllowed;
model.IsReturnRequestAllowed = _orderProcessingService.IsReturnRequestAllowed(order);
model.DisplayPdfInvoice = pdfSettings.Enabled;
model.RenderOrderNotes = pdfSettings.RenderOrderNotes;
//shipping info
model.ShippingStatus = order.ShippingStatus.GetLocalizedEnum(_services.Localization, _services.WorkContext);
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.ShippingAddress.PrepareModel(order.ShippingAddress, false, addressSettings);
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);
}
}
//billing info
model.BillingAddress.PrepareModel(order.BillingAddress, false, addressSettings);
//VAT number
model.VatNumber = order.VatNumber;
//payment method
var paymentMethod = _paymentService.LoadPaymentMethodBySystemName(order.PaymentMethodSystemName);
model.PaymentMethod = paymentMethod != null?_pluginMediator.GetLocalizedFriendlyName(paymentMethod.Metadata) : order.PaymentMethodSystemName;
model.CanRePostProcessPayment = _paymentService.CanRePostProcessPayment(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("Payments.PurchaseOrder", StringComparison.InvariantCultureIgnoreCase))
{
model.DisplayPurchaseOrderNumber = true;
model.PurchaseOrderNumber = order.PurchaseOrderNumber;
}
// totals
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
//order subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = _priceFormatter.FormatPrice(orderSubtotalExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _services.WorkContext.WorkingLanguage, false, 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, _services.WorkContext.WorkingLanguage, false, false);
}
//order shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = _priceFormatter.FormatShippingPrice(orderShippingExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _services.WorkContext.WorkingLanguage, false, 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, _services.WorkContext.WorkingLanguage, false, false);
}
}
break;
case TaxDisplayType.IncludingTax:
{
//order subtotal
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
model.OrderSubtotal = _priceFormatter.FormatPrice(orderSubtotalInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _services.WorkContext.WorkingLanguage, true, false);
//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, _services.WorkContext.WorkingLanguage, true, false);
}
//order shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
model.OrderShipping = _priceFormatter.FormatShippingPrice(orderShippingInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _services.WorkContext.WorkingLanguage, true, false);
//payment method additional fee
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeInclTaxInCustomerCurrency != decimal.Zero)
{
model.PaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _services.WorkContext.WorkingLanguage, true, false);
}
}
break;
}
//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.Count > 0;
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
//TODO pass languageId to _priceFormatter.FormatPrice
model.Tax = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, false, _services.WorkContext.WorkingLanguage);
foreach (var tr in order.TaxRatesDictionary)
{
var rate = _priceFormatter.FormatTaxRate(tr.Key);
var labelKey = "ShoppingCart.Totals.TaxRateLine" + (_services.WorkContext.TaxDisplayType == TaxDisplayType.IncludingTax ? "Incl" : "Excl");
model.TaxRates.Add(new OrderDetailsModel.TaxRate()
{
Rate = rate,
Label = T(labelKey).Text.FormatCurrent(rate),
//TODO pass languageId to _priceFormatter.FormatPrice
Value = _priceFormatter.FormatPrice(_currencyService.ConvertCurrency(tr.Value, order.CurrencyRate), true, order.CustomerCurrencyCode, false, _services.WorkContext.WorkingLanguage),
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
//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, _services.WorkContext.WorkingLanguage);
}
//gift cards
foreach (var gcuh in order.GiftCardUsageHistory)
{
model.GiftCards.Add(new OrderDetailsModel.GiftCard()
{
CouponCode = gcuh.GiftCard.GiftCardCouponCode,
Amount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, _services.WorkContext.WorkingLanguage),
});
}
//reward points
if (order.RedeemedRewardPointsEntry != null)
{
model.RedeemedRewardPoints = -order.RedeemedRewardPointsEntry.Points;
model.RedeemedRewardPointsAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(order.RedeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, _services.WorkContext.WorkingLanguage);
}
//total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
model.OrderTotal = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, _services.WorkContext.WorkingLanguage);
//checkout attributes
model.CheckoutAttributeInfo = HtmlUtils.ConvertPlainTextToTable(HtmlUtils.ConvertHtmlToPlainText(order.CheckoutAttributeDescription));
//order notes
foreach (var orderNote in order.OrderNotes
.Where(on => on.DisplayToCustomer)
.OrderByDescending(on => on.CreatedOnUtc)
.ToList())
{
model.OrderNotes.Add(new OrderDetailsModel.OrderNote()
{
Note = orderNote.FormatOrderNoteText(),
CreatedOn = _dateTimeHelper.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc)
});
}
//purchased products
model.ShowSku = catalogSettings.ShowProductSku;
var orderItems = _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
var orderItemModel = PrepareOrderItemModel(order, orderItem);
model.Items.Add(orderItemModel);
}
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,
AllowCredit = _orderSettings.IsCredit,
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)
{
_addressModelFactory.PrepareAddressModel(model.ShippingAddress,
address: order.ShippingAddress,
excludeProperties: false,
addressSettings: _addressSettings);
}
else
if (order.PickupAddress != null)
{
model.PickupAddress = new AddressModel
{
Address1 = order.PickupAddress.Address1,
City = order.PickupAddress.City,
County = order.PickupAddress.County,
CountryName = order.PickupAddress.Country != null ? order.PickupAddress.Country.Name : string.Empty,
ZipPostalCode = order.PickupAddress.ZipPostalCode
}
}
;
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);
}
}
//billing info
_addressModelFactory.PrepareAddressModel(model.BillingAddress,
address: order.BillingAddress,
excludeProperties: false,
addressSettings: _addressSettings);
//VAT number
model.VatNumber = order.VatNumber;
//payment method
var paymentMethod = _paymentPluginManager.LoadPluginBySystemName(order.PaymentMethodSystemName);
model.PaymentMethod = paymentMethod != null?_localizationService.GetLocalizedFriendlyName(paymentMethod, _workContext.WorkingLanguage.Id) : 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, _workContext.WorkingLanguage, 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, _workContext.WorkingLanguage, true);
}
}
else
{
//excluding tax
//order subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = _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 = _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 = _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 = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
}
else
{
//excluding tax
//order shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = _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 = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, 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);
//TODO pass languageId to _priceFormatter.FormatPrice
model.Tax = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
foreach (var tr in taxRates)
{
model.TaxRates.Add(new OrderDetailsModel.TaxRate
{
Rate = _priceFormatter.FormatTaxRate(tr.Key),
//TODO pass languageId to _priceFormatter.FormatPrice
Value = _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 = _priceFormatter.FormatPrice(-orderDiscountInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
}
//gift cards
foreach (var gcuh in order.GiftCardUsageHistory)
{
model.GiftCards.Add(new OrderDetailsModel.GiftCard
{
CouponCode = gcuh.GiftCard.GiftCardCouponCode,
Amount = _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 = _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 = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
//checkout attributes
model.CheckoutAttributeInfo = order.CheckoutAttributeDescription;
//order notes
foreach (var orderNote in order.OrderNotes
.Where(on => on.DisplayToCustomer)
.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 = order.OrderItems;
var vendors = _vendorSettings.ShowVendorOnOrderDetailsPage ? _vendorService.GetVendorsByIds(orderItems.Select(item => item.Product.VendorId).ToArray()) : new List <Vendor>();
foreach (var orderItem in orderItems)
{
var orderItemModel = new OrderDetailsModel.OrderItemModel
{
Id = orderItem.Id,
OrderItemGuid = orderItem.OrderItemGuid,
Sku = _productService.FormatSku(orderItem.Product, orderItem.AttributesXml),
VendorName = vendors.FirstOrDefault(v => v.Id == orderItem.Product.VendorId)?.Name ?? string.Empty,
ProductId = orderItem.Product.Id,
ProductName = _localizationService.GetLocalized(orderItem.Product, x => x.Name),
ProductSeName = _urlRecordService.GetSeName(orderItem.Product),
Quantity = orderItem.Quantity,
AttributeInfo = orderItem.AttributeDescription,
};
//rental info
if (orderItem.Product.IsRental)
{
var rentalStartDate = orderItem.RentalStartDateUtc.HasValue
? _productService.FormatRentalDate(orderItem.Product, orderItem.RentalStartDateUtc.Value) : "";
var rentalEndDate = orderItem.RentalEndDateUtc.HasValue
? _productService.FormatRentalDate(orderItem.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, _workContext.WorkingLanguage, true);
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
//downloadable products
if (_downloadService.IsDownloadAllowed(orderItem))
{
orderItemModel.DownloadId = orderItem.Product.DownloadId;
}
if (_downloadService.IsLicenseDownloadAllowed(orderItem))
{
orderItemModel.LicenseId = orderItem.LicenseDownloadId.HasValue ? orderItem.LicenseDownloadId.Value : 0;
}
}
return(model);
}