private async Task PrepareOrderTotal(GetOrderDetails request, OrderDetailsModel model)
{
if (request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal)
{
//including tax
//order subtotal
model.OrderSubtotal = await _priceFormatter.FormatPrice(request.Order.OrderSubtotalInclTax, true, request.Order.CustomerCurrencyCode, request.Language, true);
//discount (applied to order subtotal)
if (request.Order.OrderSubTotalDiscountInclTax > decimal.Zero)
{
model.OrderSubTotalDiscount = await _priceFormatter.FormatPrice(-request.Order.OrderSubTotalDiscountInclTax, true, request.Order.CustomerCurrencyCode, request.Language, true);
}
}
else
{
//excluding tax
//order subtotal
model.OrderSubtotal = await _priceFormatter.FormatPrice(request.Order.OrderSubtotalExclTax, true, request.Order.CustomerCurrencyCode, request.Language, false);
//discount (applied to order subtotal)
if (request.Order.OrderSubTotalDiscountExclTax > decimal.Zero)
{
model.OrderSubTotalDiscount = await _priceFormatter.FormatPrice(-request.Order.OrderSubTotalDiscountExclTax, true, request.Order.CustomerCurrencyCode, request.Language, false);
}
}
if (request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
//order shipping
model.OrderShipping = await _priceFormatter.FormatShippingPrice(request.Order.OrderShippingInclTax, true, request.Order.CustomerCurrencyCode, request.Language, true);
//payment method additional fee
if (request.Order.PaymentMethodAdditionalFeeInclTax > decimal.Zero)
{
model.PaymentMethodAdditionalFee = await _priceFormatter.FormatPaymentMethodAdditionalFee(request.Order.PaymentMethodAdditionalFeeInclTax, true, request.Order.CustomerCurrencyCode, request.Language, true);
}
}
else
{
//excluding tax
//order shipping
model.OrderShipping = await _priceFormatter.FormatShippingPrice(request.Order.OrderShippingExclTax, true, request.Order.CustomerCurrencyCode, request.Language, false);
//payment method additional fee
if (request.Order.PaymentMethodAdditionalFeeExclTax > decimal.Zero)
{
model.PaymentMethodAdditionalFee = await _priceFormatter.FormatPaymentMethodAdditionalFee(request.Order.PaymentMethodAdditionalFeeExclTax, true, request.Order.CustomerCurrencyCode, request.Language, false);
}
}
//total
model.OrderTotal = await _priceFormatter.FormatPrice(request.Order.OrderTotal, true, request.Order.CustomerCurrencyCode, false, request.Language);
}
public ActionResult GetOrderShipReportList(DataSourceRequest command, OrderReportModel model)
{
DateTime?startDateValue = (model.StartDate == null) ? null
: (DateTime?)_dateTimeHelper.ConvertToUtcTime(model.StartDate.Value, _dateTimeHelper.CurrentTimeZone);
DateTime?endDateValue = (model.EndDate == null) ? null
: (DateTime?)_dateTimeHelper.ConvertToUtcTime(model.EndDate.Value, _dateTimeHelper.CurrentTimeZone).AddDays(1);
OrderStatus?orderStatus = model.OrderStatusId > 0 ? (OrderStatus?)(model.OrderStatusId) : null;
orderStatus = OrderStatus.Complete;
//load orders
var orders = _orderService.SearchOrders(0, 0, 0, 0, 0,
startDateValue, endDateValue, orderStatus,
null, null, null, null,
command.Page - 1, command.PageSize);
var gridModel = new DataSourceResult
{
Data = orders.Select(x =>
{
return(new OrderModel()
{
Id = x.Id,
OrderShippingExclTax = _priceFormatter.FormatPrice(x.OrderShippingExclTax, true, false),
OrderStatus = x.OrderStatus.GetLocalizedEnum(_localizationService, _workContext),
CustomerEmail = x.BillingAddress.Email,
CustomerFullName = string.Format("{0} {1}", x.BillingAddress.FirstName, x.BillingAddress.LastName),
CreatedOn = _dateTimeHelper.ConvertToUserTime(x.CreatedOnUtc, DateTimeKind.Utc)
});
}),
Total = orders.TotalCount,
};
//summary report
var reportSummary = _orderReportService.GetOrderAverageReportLine(0,
0, orderStatus, null, null,
startDateValue, endDateValue, null);
gridModel.ExtraData = new OrderAggreratorModel()
{
aggregatorshipping = _priceFormatter.FormatShippingPrice(reportSummary.SumShippingExclTax, true),
avgShipping = _priceFormatter.FormatPrice(reportSummary.SumShippingExclTax / gridModel.Total, true, false)
};
return(Json(gridModel));
}
private async Task PrepareShippingInfo(OrderTotalsModel model, GetOrderTotals request)
{
model.RequiresShipping = request.Cart.RequiresShipping();
if (model.RequiresShipping)
{
decimal?shoppingCartShippingBase = (await _orderTotalCalculationService.GetShoppingCartShippingTotal(request.Cart)).shoppingCartShippingTotal;
if (shoppingCartShippingBase.HasValue)
{
model.Shipping = _priceFormatter.FormatShippingPrice(shoppingCartShippingBase.Value, true);
//selected shipping method
var shippingOption = request.Customer.GetAttributeFromEntity <ShippingOption>(SystemCustomerAttributeNames.SelectedShippingOption, request.Store.Id);
if (shippingOption != null)
{
model.SelectedShippingMethod = shippingOption.Name;
}
}
}
}
public async Task <IActionResult> Get(string shippingOptionId)
{
var shippingPoint = await _shippingPointService.GetStoreShippingPointById(shippingOptionId);
if (shippingPoint != null)
{
var viewModel = new PointModel()
{
ShippingPointName = shippingPoint.ShippingPointName,
Description = shippingPoint.Description,
PickupFee = _priceFormatter.FormatShippingPrice(shippingPoint.PickupFee),
OpeningHours = shippingPoint.OpeningHours,
Address1 = shippingPoint.Address1,
City = shippingPoint.City,
CountryName = (await _countryService.GetCountryById(shippingPoint.CountryId))?.Name,
ZipPostalCode = shippingPoint.ZipPostalCode,
};
return(View(viewModel));
}
return(Content("ShippingPointController: given Shipping Option doesn't exist"));
}
public IActionResult Get(string shippingOptionId)
{
var shippingPoint = _shippingPointService.GetStoreShippingPointById(shippingOptionId);
if (shippingPoint != null)
{
var countryName = _countryService.GetCountryById(shippingPoint.CountryId);
var viewModel = new PointModel()
{
ShippingPointName = shippingPoint.ShippingPointName,
Description = shippingPoint.Description,
PickupFee = _priceFormatter.FormatShippingPrice(shippingPoint.PickupFee, true),
OpeningHours = shippingPoint.OpeningHours,
Address1 = shippingPoint.Address1,
City = shippingPoint.City,
CountryName = _countryService.GetCountryById(shippingPoint.CountryId)?.Name,
ZipPostalCode = shippingPoint.ZipPostalCode,
};
return(View("~/Plugins/Shipping.ShippingPoint/Views/FormShippingOption.cshtml", viewModel));
}
return(Content("ShippingPointController: given Shipping Option doesn't exist"));
}
private async Task PreparePickupPoints(CheckoutShippingAddressModel model, GetShippingAddress request)
{
var pickupPoints = await _shippingService.LoadActivePickupPoints(request.Store.Id);
if (pickupPoints.Any())
{
foreach (var pickupPoint in pickupPoints)
{
var pickupPointModel = new CheckoutPickupPointModel()
{
Id = pickupPoint.Id,
Name = pickupPoint.Name,
Description = pickupPoint.Description,
Address = pickupPoint.Address,
};
if (pickupPoint.PickupFee > 0)
{
var amount = (await _taxService.GetShippingPrice(pickupPoint.PickupFee, request.Customer)).shippingPrice;
amount = await _currencyService.ConvertFromPrimaryStoreCurrency(amount, request.Currency);
pickupPointModel.PickupFee = _priceFormatter.FormatShippingPrice(amount, true);
}
model.PickupPoints.Add(pickupPointModel);
}
}
if (!(await _shippingService.LoadActiveShippingRateComputationMethods(request.Store.Id)).Any())
{
if (!pickupPoints.Any())
{
model.Warnings.Add(_localizationService.GetResource("Checkout.ShippingIsNotAllowed"));
model.Warnings.Add(_localizationService.GetResource("Checkout.PickupPoints.NotAvailable"));
}
model.PickUpInStoreOnly = true;
model.PickUpInStore = true;
}
}
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);
}
private void CalculateSubTotals()
{
_displaySubTotalDiscount = false;
_cusSubTotalDiscount = string.Empty;
if (_order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal)
{
//including tax
//subtotal
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(_order.OrderSubtotalInclTax, _order.CurrencyRate);
_cusSubTotal = _priceFormatter.FormatPrice(orderSubtotalInclTaxInCustomerCurrency, true, _order.CustomerCurrencyCode, _language, true);
//discount (applied to order subtotal)
var orderSubTotalDiscountInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(_order.OrderSubTotalDiscountInclTax, _order.CurrencyRate);
if (orderSubTotalDiscountInclTaxInCustomerCurrency > decimal.Zero)
{
_cusSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, _order.CustomerCurrencyCode, _language, true);
_displaySubTotalDiscount = true;
}
}
else
{
//exсluding tax
//subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(_order.OrderSubtotalExclTax, _order.CurrencyRate);
_cusSubTotal = _priceFormatter.FormatPrice(orderSubtotalExclTaxInCustomerCurrency, true, _order.CustomerCurrencyCode, _language, false);
//discount (applied to order subtotal)
var orderSubTotalDiscountExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(_order.OrderSubTotalDiscountExclTax, _order.CurrencyRate);
if (orderSubTotalDiscountExclTaxInCustomerCurrency > decimal.Zero)
{
_cusSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, _order.CustomerCurrencyCode, _language, false);
_displaySubTotalDiscount = true;
}
}
//shipping, payment method fee
_taxRates = new SortedDictionary <decimal, decimal>();
_cusTaxTotal = string.Empty;
_cusDiscount = string.Empty;
if (_order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
//shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(_order.OrderShippingInclTax, _order.CurrencyRate);
_cusShipTotal = _priceFormatter.FormatShippingPrice(orderShippingInclTaxInCustomerCurrency, true, _order.CustomerCurrencyCode, _language, true);
//payment method additional fee
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(_order.PaymentMethodAdditionalFeeInclTax, _order.CurrencyRate);
_cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, _order.CustomerCurrencyCode, _language, true);
}
else
{
//excluding tax
//shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(_order.OrderShippingExclTax, _order.CurrencyRate);
_cusShipTotal = _priceFormatter.FormatShippingPrice(orderShippingExclTaxInCustomerCurrency, true, _order.CustomerCurrencyCode, _language, false);
//payment method additional fee
var paymentMethodAdditionalFeeExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(_order.PaymentMethodAdditionalFeeExclTax, _order.CurrencyRate);
_cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, _order.CustomerCurrencyCode, _language, false);
}
//shipping
bool displayShipping = _order.ShippingStatus != ShippingStatus.ShippingNotRequired;
//payment method fee
bool displayPaymentMethodFee = _order.PaymentMethodAdditionalFeeExclTax > decimal.Zero;
//tax
_displayTax = true;
_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
{
_taxRates = new SortedDictionary <decimal, decimal>();
foreach (var tr in _order.TaxRatesDictionary)
{
_taxRates.Add(tr.Key, _currencyService.ConvertCurrency(tr.Value, _order.CurrencyRate));
}
_displayTaxRates = _taxSettings.DisplayTaxRates && _taxRates.Any();
_displayTax = !_displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(_order.OrderTax, _order.CurrencyRate);
string taxStr = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, _currency, _language, _order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
_cusTaxTotal = taxStr;
}
}
//discount
_displayDiscount = false;
if (_order.OrderDiscount > decimal.Zero)
{
var orderDiscountInCustomerCurrency = _currencyService.ConvertCurrency(_order.OrderDiscount, _order.CurrencyRate);
_cusDiscount = _priceFormatter.FormatPrice(-orderDiscountInCustomerCurrency, true, _currency, _language, _order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
_displayDiscount = true;
}
//total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(_order.OrderTotal, _order.CurrencyRate);
_cusTotal = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, _currency, _language, _order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
}
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 virtual ActionResult OrderList(DataSourceRequest command, Admin.Models.Orders.OrderListModel model)
{
var storeScope = this.GetActiveStoreScopeConfiguration(_storeService, _workContext);
var amazonSettings = _settingService.LoadSetting<OrderAmazonSettings>(storeScope);
if (!_permissionService.Authorize(StandardPermissionProvider.ManageOrders))
return AccessDeniedKendoGridJson();
//a vendor should have access only to his products
if (_workContext.CurrentVendor != null)
{
model.VendorId = _workContext.CurrentVendor.Id;
}
DateTime? startDateValue = (model.StartDate == null) ? null
: (DateTime?)_dateTimeHelper.ConvertToUtcTime(model.StartDate.Value, _dateTimeHelper.CurrentTimeZone);
DateTime? endDateValue = (model.EndDate == null) ? null
: (DateTime?)_dateTimeHelper.ConvertToUtcTime(model.EndDate.Value, _dateTimeHelper.CurrentTimeZone).AddDays(1);
var orderStatusIds = !model.OrderStatusIds.Contains(0) ? model.OrderStatusIds : null;
var paymentStatusIds = !model.PaymentStatusIds.Contains(0) ? model.PaymentStatusIds : null;
var shippingStatusIds = !model.ShippingStatusIds.Contains(0) ? model.ShippingStatusIds : null;
var filterByProductId = 0;
var product = _productService.GetProductById(model.ProductId);
if (product != null && HasAccessToProduct(product))
filterByProductId = model.ProductId;
//load orders
var orders = _orderAmazonService.SearchOrders(storeId: model.StoreId,
vendorId: model.VendorId,
productId: filterByProductId,
warehouseId: model.WarehouseId,
paymentMethodSystemName: model.PaymentMethodSystemName,
createdFromUtc: startDateValue,
createdToUtc: endDateValue,
osIds: orderStatusIds,
psIds: paymentStatusIds,
ssIds: shippingStatusIds,
billingEmail: model.BillingEmail,
billingLastName: model.BillingLastName,
billingCountryId: model.BillingCountryId,
orderNotes: model.OrderNotes,
pageIndex: command.Page - 1,
pageSize: command.PageSize);
var gridModel = new DataSourceResult
{
Data = orders.Select(x =>
{
var store = _storeService.GetStoreById(x.StoreId);
return new OrderModel
{
Id = x.Id,
StoreName = store != null ? store.Name : "Unknown",
OrderTotal = _priceFormatter.FormatPrice(x.OrderTotal, true, false),
OrderStatus = x.OrderStatus.GetLocalizedEnum(_localizationService, _workContext),
OrderStatusId = x.OrderStatusId,
PaymentStatus = x.PaymentStatus.GetLocalizedEnum(_localizationService, _workContext),
PaymentStatusId = x.PaymentStatusId,
ShippingStatus = x.ShippingStatus.GetLocalizedEnum(_localizationService, _workContext),
ShippingStatusId = x.ShippingStatusId,
CustomerEmail = x.BillingAddress.Email,
CustomerFullName = string.Format("{0} {1}", x.BillingAddress.FirstName, x.BillingAddress.LastName),
CreatedOn = _dateTimeHelper.ConvertToUserTime(x.CreatedOnUtc, DateTimeKind.Utc),
CustomOrderNumber = x.CustomOrderNumber,
OrderAmazon = _orderAmazonService.GetOrderAmazonByOrderId(x.Id)
};
}),
Total = orders.TotalCount
};
//summary report
//currently we do not support productId and warehouseId parameters for this report
var reportSummary = _orderReportService.GetOrderAverageReportLine(
storeId: model.StoreId,
vendorId: model.VendorId,
orderId: 0,
paymentMethodSystemName: model.PaymentMethodSystemName,
osIds: orderStatusIds,
psIds: paymentStatusIds,
ssIds: shippingStatusIds,
startTimeUtc: startDateValue,
endTimeUtc: endDateValue,
billingEmail: model.BillingEmail,
billingLastName: model.BillingLastName,
billingCountryId: model.BillingCountryId,
orderNotes: model.OrderNotes);
var profit = _orderReportService.ProfitReport(
storeId: model.StoreId,
vendorId: model.VendorId,
paymentMethodSystemName: model.PaymentMethodSystemName,
osIds: orderStatusIds,
psIds: paymentStatusIds,
ssIds: shippingStatusIds,
startTimeUtc: startDateValue,
endTimeUtc: endDateValue,
billingEmail: model.BillingEmail,
billingLastName: model.BillingLastName,
billingCountryId: model.BillingCountryId,
orderNotes: model.OrderNotes);
var primaryStoreCurrency = _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId);
if (primaryStoreCurrency == null)
throw new Exception("Cannot load primary store currency");
gridModel.ExtraData = new Admin.Models.Orders.OrderAggreratorModel
{
aggregatorprofit = _priceFormatter.FormatPrice(profit, true, false),
aggregatorshipping = _priceFormatter.FormatShippingPrice(reportSummary.SumShippingExclTax, true, primaryStoreCurrency, _workContext.WorkingLanguage, false),
aggregatortax = _priceFormatter.FormatPrice(reportSummary.SumTax, true, false),
aggregatortotal = _priceFormatter.FormatPrice(reportSummary.SumOrders, true, false)
};
return Json(gridModel);
}
public async Task <CheckoutShippingMethodModel> Handle(GetShippingMethod request, CancellationToken cancellationToken)
{
var model = new CheckoutShippingMethodModel();
var getShippingOptionResponse = await _shippingService
.GetShippingOptions(request.Customer, request.Cart, request.ShippingAddress,
"", request.Store);
if (getShippingOptionResponse.Success)
{
//performance optimization. cache returned shipping options.
//we'll use them later (after a customer has selected an option).
await _userFieldService.SaveField(request.Customer,
SystemCustomerFieldNames.OfferedShippingOptions,
getShippingOptionResponse.ShippingOptions,
request.Store.Id);
foreach (var shippingOption in getShippingOptionResponse.ShippingOptions)
{
var soModel = new CheckoutShippingMethodModel.ShippingMethodModel
{
Name = shippingOption.Name,
Description = shippingOption.Description,
ShippingRateProviderSystemName = shippingOption.ShippingRateProviderSystemName,
ShippingOption = shippingOption,
};
//adjust rate
var shippingTotal = (await _orderTotalCalculationService.AdjustShippingRate(
shippingOption.Rate, request.Cart)).shippingRate;
double rateBase = (await _taxService.GetShippingPrice(shippingTotal, request.Customer)).shippingPrice;
soModel.Fee = _priceFormatter.FormatShippingPrice(rateBase);
model.ShippingMethods.Add(soModel);
}
//find a selected (previously) shipping method
var selectedShippingOption = request.Customer.GetUserFieldFromEntity <ShippingOption>(SystemCustomerFieldNames.SelectedShippingOption, request.Store.Id);
if (selectedShippingOption != null)
{
var shippingOptionToSelect = model.ShippingMethods.ToList()
.Find(so =>
!String.IsNullOrEmpty(so.Name) &&
so.Name.Equals(selectedShippingOption.Name, StringComparison.OrdinalIgnoreCase) &&
!String.IsNullOrEmpty(so.ShippingRateProviderSystemName) &&
so.ShippingRateProviderSystemName.Equals(selectedShippingOption.ShippingRateProviderSystemName, StringComparison.OrdinalIgnoreCase));
if (shippingOptionToSelect != null)
{
shippingOptionToSelect.Selected = true;
}
}
//if no option has been selected, do it for the first one
if (model.ShippingMethods.FirstOrDefault(so => so.Selected) == null)
{
var shippingOptionToSelect = model.ShippingMethods.FirstOrDefault();
if (shippingOptionToSelect != null)
{
shippingOptionToSelect.Selected = true;
}
}
}
else
{
foreach (var error in getShippingOptionResponse.Errors)
{
model.Warnings.Add(error);
}
}
return(model);
}
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);
}
/// <summary>
/// Prepares the checkout pickup points model
/// </summary>
/// <param name="cart">Cart</param>
/// <returns>The checkout pickup points model</returns>
protected virtual CheckoutPickupPointsModel PrepareCheckoutPickupPointsModel(IList <ShoppingCartItem> cart)
{
var model = new CheckoutPickupPointsModel()
{
AllowPickupInStore = _shippingSettings.AllowPickupInStore
};
if (model.AllowPickupInStore)
{
model.DisplayPickupPointsOnMap = _shippingSettings.DisplayPickupPointsOnMap;
model.GoogleMapsApiKey = _shippingSettings.GoogleMapsApiKey;
var pickupPointProviders = _pickupPluginManager.LoadActivePlugins(_workContext.CurrentCustomer, _storeContext.CurrentStore.Id);
if (pickupPointProviders.Any())
{
var languageId = _workContext.WorkingLanguage.Id;
var pickupPointsResponse = _shippingService.GetPickupPoints(_workContext.CurrentCustomer.BillingAddressId ?? 0,
_workContext.CurrentCustomer, storeId: _storeContext.CurrentStore.Id);
if (pickupPointsResponse.Success)
{
model.PickupPoints = pickupPointsResponse.PickupPoints.Select(point =>
{
var country = _countryService.GetCountryByTwoLetterIsoCode(point.CountryCode);
var state = _stateProvinceService.GetStateProvinceByAbbreviation(point.StateAbbreviation, country?.Id);
var pickupPointModel = new CheckoutPickupPointModel
{
Id = point.Id,
Name = point.Name,
Description = point.Description,
ProviderSystemName = point.ProviderSystemName,
Address = point.Address,
City = point.City,
County = point.County,
StateName = state != null ? _localizationService.GetLocalized(state, x => x.Name, languageId) : string.Empty,
CountryName = country != null ? _localizationService.GetLocalized(country, x => x.Name, languageId) : string.Empty,
ZipPostalCode = point.ZipPostalCode,
Latitude = point.Latitude,
Longitude = point.Longitude,
OpeningHours = point.OpeningHours
};
var cart = _shoppingCartService.GetShoppingCart(_workContext.CurrentCustomer, ShoppingCartType.ShoppingCart, _storeContext.CurrentStore.Id);
var amount = _orderTotalCalculationService.IsFreeShipping(cart) ? 0 : point.PickupFee;
if (amount > 0)
{
amount = _taxService.GetShippingPrice(amount, _workContext.CurrentCustomer);
amount = _currencyService.ConvertFromPrimaryStoreCurrency(amount, _workContext.WorkingCurrency);
pickupPointModel.PickupFee = _priceFormatter.FormatShippingPrice(amount, true);
}
//adjust rate
var shippingTotal = _orderTotalCalculationService.AdjustShippingRate(point.PickupFee, cart, out var _, true);
var rateBase = _taxService.GetShippingPrice(shippingTotal, _workContext.CurrentCustomer);
var rate = _currencyService.ConvertFromPrimaryStoreCurrency(rateBase, _workContext.WorkingCurrency);
pickupPointModel.PickupFee = _priceFormatter.FormatShippingPrice(rate, true);
return(pickupPointModel);
}).ToList();
}
else
{
foreach (var error in pickupPointsResponse.Errors)
{
model.Warnings.Add(error);
}
}
}
//only available pickup points
var shippingProviders = _shippingPluginManager.LoadActivePlugins(_workContext.CurrentCustomer, _storeContext.CurrentStore.Id);
if (!shippingProviders.Any())
{
if (!pickupPointProviders.Any())
{
model.Warnings.Add(_localizationService.GetResource("Checkout.ShippingIsNotAllowed"));
model.Warnings.Add(_localizationService.GetResource("Checkout.PickupPoints.NotAvailable"));
}
model.PickupInStoreOnly = true;
model.PickupInStore = true;
return(model);
}
}
return(model);
}
/// <summary>
/// Prepare the order totals model
/// </summary>
/// <param name="cart">List of the shopping cart item</param>
/// <param name="isEditable">Whether model is editable</param>
/// <returns>Order totals model</returns>
public override OrderTotalsModel PrepareOrderTotalsModel(IList <ShoppingCartItem> cart, bool isEditable)
{
var model = new OrderTotalsModel
{
IsEditable = isEditable
};
if (cart.Any())
{
//Avalara plugin changes
PrepareTaxDetails(cart);
//Avalara plugin changes
//subtotal
var subTotalIncludingTax = _workContext.TaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal;
_orderTotalCalculationService.GetShoppingCartSubTotal(cart, subTotalIncludingTax, out var orderSubTotalDiscountAmountBase, out var _, out var subTotalWithoutDiscountBase, out var _);
var subtotalBase = subTotalWithoutDiscountBase;
var subtotal = _currencyService.ConvertFromPrimaryStoreCurrency(subtotalBase, _workContext.WorkingCurrency);
model.SubTotal = _priceFormatter.FormatPrice(subtotal, true, _workContext.WorkingCurrency, _workContext.WorkingLanguage, subTotalIncludingTax);
if (orderSubTotalDiscountAmountBase > decimal.Zero)
{
var orderSubTotalDiscountAmount = _currencyService.ConvertFromPrimaryStoreCurrency(orderSubTotalDiscountAmountBase, _workContext.WorkingCurrency);
model.SubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountAmount, true, _workContext.WorkingCurrency, _workContext.WorkingLanguage, subTotalIncludingTax);
}
//LoadAllShippingRateComputationMethods
var shippingRateComputationMethods = _shippingPluginManager.LoadActivePlugins(_workContext.CurrentCustomer, _storeContext.CurrentStore.Id);
//shipping info
model.RequiresShipping = _shoppingCartService.ShoppingCartRequiresShipping(cart);
if (model.RequiresShipping)
{
var shoppingCartShippingBase = _orderTotalCalculationService.GetShoppingCartShippingTotal(cart, shippingRateComputationMethods);
if (shoppingCartShippingBase.HasValue)
{
var shoppingCartShipping = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartShippingBase.Value, _workContext.WorkingCurrency);
model.Shipping = _priceFormatter.FormatShippingPrice(shoppingCartShipping, true);
//selected shipping method
var shippingOption = _genericAttributeService.GetAttribute <ShippingOption>(_workContext.CurrentCustomer,
NopCustomerDefaults.SelectedShippingOptionAttribute, _storeContext.CurrentStore.Id);
if (shippingOption != null)
{
model.SelectedShippingMethod = shippingOption.Name;
}
}
}
else
{
model.HideShippingTotal = _shippingSettings.HideShippingTotal;
}
//payment method fee
var paymentMethodSystemName = _genericAttributeService.GetAttribute <string>(_workContext.CurrentCustomer, NopCustomerDefaults.SelectedPaymentMethodAttribute, _storeContext.CurrentStore.Id);
var paymentMethodAdditionalFee = _paymentService.GetAdditionalHandlingFee(cart, paymentMethodSystemName);
var paymentMethodAdditionalFeeWithTaxBase = _taxService.GetPaymentMethodAdditionalFee(paymentMethodAdditionalFee, _workContext.CurrentCustomer);
if (paymentMethodAdditionalFeeWithTaxBase > decimal.Zero)
{
var paymentMethodAdditionalFeeWithTax = _currencyService.ConvertFromPrimaryStoreCurrency(paymentMethodAdditionalFeeWithTaxBase, _workContext.WorkingCurrency);
model.PaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeWithTax, true);
}
//tax
var displayTax = true;
var displayTaxRates = true;
if (_taxSettings.HideTaxInOrderSummary && _workContext.TaxDisplayType == TaxDisplayType.IncludingTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
var shoppingCartTaxBase = _orderTotalCalculationService.GetTaxTotal(cart, shippingRateComputationMethods, out var taxRates);
//Avalara plugin changes
//get tax details from the Avalara tax service, it may slightly differ from the original calculated tax
var taxDetails = _httpContextAccessor.HttpContext.Session.Get <TaxDetails>(AvalaraTaxDefaults.TaxDetailsSessionValue);
if (taxDetails != null)
{
//adjust tax total according to received value from the Avalara
if (taxDetails.TaxTotal.HasValue)
{
shoppingCartTaxBase = taxDetails.TaxTotal.Value;
}
if (taxDetails.TaxRates?.Any() ?? false)
{
taxRates = new SortedDictionary <decimal, decimal>(taxDetails.TaxRates);
}
}
//Avalara plugin changes
var shoppingCartTax = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartTaxBase, _workContext.WorkingCurrency);
if (shoppingCartTaxBase == 0 && _taxSettings.HideZeroTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
displayTaxRates = _taxSettings.DisplayTaxRates && taxRates.Any();
displayTax = !displayTaxRates;
model.Tax = _priceFormatter.FormatPrice(shoppingCartTax, true, false);
foreach (var tr in taxRates)
{
model.TaxRates.Add(new OrderTotalsModel.TaxRate
{
Rate = _priceFormatter.FormatTaxRate(tr.Key),
Value = _priceFormatter.FormatPrice(_currencyService.ConvertFromPrimaryStoreCurrency(tr.Value, _workContext.WorkingCurrency), true, false),
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
//total
var shoppingCartTotalBase = _orderTotalCalculationService.GetShoppingCartTotal(cart, out var orderTotalDiscountAmountBase, out var _, out var appliedGiftCards, out var redeemedRewardPoints, out var redeemedRewardPointsAmount);
if (shoppingCartTotalBase.HasValue)
{
var shoppingCartTotal = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartTotalBase.Value, _workContext.WorkingCurrency);
model.OrderTotal = _priceFormatter.FormatPrice(shoppingCartTotal, true, false);
}
//discount
if (orderTotalDiscountAmountBase > decimal.Zero)
{
var orderTotalDiscountAmount = _currencyService.ConvertFromPrimaryStoreCurrency(orderTotalDiscountAmountBase, _workContext.WorkingCurrency);
model.OrderTotalDiscount = _priceFormatter.FormatPrice(-orderTotalDiscountAmount, true, false);
}
//gift cards
if (appliedGiftCards != null && appliedGiftCards.Any())
{
foreach (var appliedGiftCard in appliedGiftCards)
{
var gcModel = new OrderTotalsModel.GiftCard
{
Id = appliedGiftCard.GiftCard.Id,
CouponCode = appliedGiftCard.GiftCard.GiftCardCouponCode,
};
var amountCanBeUsed = _currencyService.ConvertFromPrimaryStoreCurrency(appliedGiftCard.AmountCanBeUsed, _workContext.WorkingCurrency);
gcModel.Amount = _priceFormatter.FormatPrice(-amountCanBeUsed, true, false);
var remainingAmountBase = _giftCardService.GetGiftCardRemainingAmount(appliedGiftCard.GiftCard) - appliedGiftCard.AmountCanBeUsed;
var remainingAmount = _currencyService.ConvertFromPrimaryStoreCurrency(remainingAmountBase, _workContext.WorkingCurrency);
gcModel.Remaining = _priceFormatter.FormatPrice(remainingAmount, true, false);
model.GiftCards.Add(gcModel);
}
}
//reward points to be spent (redeemed)
if (redeemedRewardPointsAmount > decimal.Zero)
{
var redeemedRewardPointsAmountInCustomerCurrency = _currencyService.ConvertFromPrimaryStoreCurrency(redeemedRewardPointsAmount, _workContext.WorkingCurrency);
model.RedeemedRewardPoints = redeemedRewardPoints;
model.RedeemedRewardPointsAmount = _priceFormatter.FormatPrice(-redeemedRewardPointsAmountInCustomerCurrency, true, false);
}
//reward points to be earned
if (_rewardPointsSettings.Enabled && _rewardPointsSettings.DisplayHowMuchWillBeEarned && shoppingCartTotalBase.HasValue)
{
//get shipping total
var shippingBaseInclTax = !model.RequiresShipping ? 0 : _orderTotalCalculationService.GetShoppingCartShippingTotal(cart, true, shippingRateComputationMethods) ?? 0;
//get total for reward points
var totalForRewardPoints = _orderTotalCalculationService
.CalculateApplicableOrderTotalForRewardPoints(shippingBaseInclTax, shoppingCartTotalBase.Value);
if (totalForRewardPoints > decimal.Zero)
{
model.WillEarnRewardPoints = _orderTotalCalculationService.CalculateRewardPoints(_workContext.CurrentCustomer, totalForRewardPoints);
}
}
}
return(model);
}
/// <summary>
/// Convert a collection to a HTML table
/// </summary>
/// <param name="order">Order</param>
/// <param name="languageId">Language identifier</param>
/// <returns>HTML table of products</returns>
protected virtual string ProductListToHtmlTable(Order order, int languageId)
{
var result = "";
var language = _languageService.GetLanguageById(languageId);
var sb = new StringBuilder();
sb.AppendLine("<table border=\"0\" style=\"width:100%;\">");
#region Products
sb.AppendLine(string.Format("<tr style=\"background-color:{0};text-align:center;\">", _templatesSettings.Color1));
sb.AppendLine(string.Format("<th>{0}</th>", _localizationService.GetResource("Messages.Order.Product(s).Name", languageId)));
sb.AppendLine(string.Format("<th>{0}</th>", _localizationService.GetResource("Messages.Order.Product(s).Price", languageId)));
sb.AppendLine(string.Format("<th>{0}</th>", _localizationService.GetResource("Messages.Order.Product(s).Quantity", languageId)));
sb.AppendLine(string.Format("<th>{0}</th>", _localizationService.GetResource("Messages.Order.Product(s).Total", languageId)));
sb.AppendLine("</tr>");
var table = order.OrderItems.ToList();
for (int i = 0; i <= table.Count - 1; i++)
{
var orderItem = table[i];
var product = orderItem.Product;
if (product == null)
{
continue;
}
sb.AppendLine(string.Format("<tr style=\"background-color: {0};text-align: center;\">", _templatesSettings.Color2));
//product name
string productName = product.GetLocalized(x => x.Name, languageId);
sb.AppendLine("<td style=\"padding: 0.6em 0.4em;text-align: left;\">" + HttpUtility.HtmlEncode(productName));
//add download link
if (_downloadService.IsDownloadAllowed(orderItem))
{
//TODO add a method for getting URL (use routing because it handles all SEO friendly URLs)
string downloadUrl = string.Format("{0}download/getdownload/{1}", _webHelper.GetStoreLocation(false), orderItem.OrderItemGuid);
string downloadLink = string.Format("<a class=\"link\" href=\"{0}\">{1}</a>", downloadUrl, _localizationService.GetResource("Messages.Order.Product(s).Download", languageId));
sb.AppendLine(" (");
sb.AppendLine(downloadLink);
sb.AppendLine(")");
}
//attributes
if (!String.IsNullOrEmpty(orderItem.AttributeDescription))
{
sb.AppendLine("<br />");
sb.AppendLine(orderItem.AttributeDescription);
}
//sku
if (_catalogSettings.ShowProductSku)
{
var sku = product.FormatSku(orderItem.AttributesXml, _productAttributeParser);
if (!String.IsNullOrEmpty(sku))
{
sb.AppendLine("<br />");
sb.AppendLine(string.Format(_localizationService.GetResource("Messages.Order.Product(s).SKU", languageId), HttpUtility.HtmlEncode(sku)));
}
}
sb.AppendLine("</td>");
string unitPriceStr = string.Empty;
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
unitPriceStr = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
unitPriceStr = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, true);
}
break;
}
sb.AppendLine(string.Format("<td style=\"padding: 0.6em 0.4em;text-align: right;\">{0}</td>", unitPriceStr));
sb.AppendLine(string.Format("<td style=\"padding: 0.6em 0.4em;text-align: center;\">{0}</td>", orderItem.Quantity));
string priceStr = string.Empty;
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
priceStr = _priceFormatter.FormatPrice(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
priceStr = _priceFormatter.FormatPrice(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, true);
}
break;
}
sb.AppendLine(string.Format("<td style=\"padding: 0.6em 0.4em;text-align: right;\">{0}</td>", priceStr));
sb.AppendLine("</tr>");
}
#endregion
#region Checkout Attributes
if (!String.IsNullOrEmpty(order.CheckoutAttributeDescription))
{
sb.AppendLine("<tr><td style=\"text-align:right;\" colspan=\"1\"> </td><td colspan=\"3\" style=\"text-align:right\">");
sb.AppendLine(order.CheckoutAttributeDescription);
sb.AppendLine("</td></tr>");
}
#endregion
#region Totals
string cusSubTotal = string.Empty;
bool dislaySubTotalDiscount = false;
string cusSubTotalDiscount = string.Empty;
string cusShipTotal = string.Empty;
string cusPaymentMethodAdditionalFee = string.Empty;
var taxRates = new SortedDictionary <decimal, decimal>();
string cusTaxTotal = string.Empty;
string cusDiscount = string.Empty;
string cusTotal = string.Empty;
//subtotal, shipping, payment method fee
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
//subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
cusSubTotal = _priceFormatter.FormatPrice(orderSubtotalExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, false);
//discount (applied to order subtotal)
var orderSubTotalDiscountExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountExclTax, order.CurrencyRate);
if (orderSubTotalDiscountExclTaxInCustomerCurrency > decimal.Zero)
{
cusSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, false);
dislaySubTotalDiscount = true;
}
//shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
cusShipTotal = _priceFormatter.FormatShippingPrice(orderShippingExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, false);
//payment method additional fee
var paymentMethodAdditionalFeeExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate);
cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, false);
}
break;
case TaxDisplayType.IncludingTax:
{
//subtotal
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
cusSubTotal = _priceFormatter.FormatPrice(orderSubtotalInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, true);
//discount (applied to order subtotal)
var orderSubTotalDiscountInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountInclTax, order.CurrencyRate);
if (orderSubTotalDiscountInclTaxInCustomerCurrency > decimal.Zero)
{
cusSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, true);
dislaySubTotalDiscount = true;
}
//shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
cusShipTotal = _priceFormatter.FormatShippingPrice(orderShippingInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, true);
//payment method additional fee
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, true);
}
break;
}
//shipping
bool dislayShipping = order.ShippingStatus != ShippingStatus.ShippingNotRequired;
//payment method fee
bool displayPaymentMethodFee = true;
if (order.PaymentMethodAdditionalFeeExclTax == decimal.Zero)
{
displayPaymentMethodFee = 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
{
taxRates = new SortedDictionary <decimal, decimal>();
foreach (var tr in order.TaxRatesDictionary)
{
taxRates.Add(tr.Key, _currencyService.ConvertCurrency(tr.Value, order.CurrencyRate));
}
displayTaxRates = _taxSettings.DisplayTaxRates && taxRates.Count > 0;
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
string taxStr = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, false, language);
cusTaxTotal = taxStr;
}
}
//discount
bool dislayDiscount = false;
if (order.OrderDiscount > decimal.Zero)
{
var orderDiscountInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderDiscount, order.CurrencyRate);
cusDiscount = _priceFormatter.FormatPrice(-orderDiscountInCustomerCurrency, true, order.CustomerCurrencyCode, false, language);
dislayDiscount = true;
}
//total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
cusTotal = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, language);
//subtotal
sb.AppendLine(string.Format("<tr style=\"text-align:right;\"><td> </td><td colspan=\"2\" style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{1}</strong></td> <td style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{2}</strong></td></tr>", _templatesSettings.Color3, _localizationService.GetResource("Messages.Order.SubTotal", languageId), cusSubTotal));
//discount (applied to order subtotal)
if (dislaySubTotalDiscount)
{
sb.AppendLine(string.Format("<tr style=\"text-align:right;\"><td> </td><td colspan=\"2\" style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{1}</strong></td> <td style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{2}</strong></td></tr>", _templatesSettings.Color3, _localizationService.GetResource("Messages.Order.SubTotalDiscount", languageId), cusSubTotalDiscount));
}
//shipping
if (dislayShipping)
{
sb.AppendLine(string.Format("<tr style=\"text-align:right;\"><td> </td><td colspan=\"2\" style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{1}</strong></td> <td style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{2}</strong></td></tr>", _templatesSettings.Color3, _localizationService.GetResource("Messages.Order.Shipping", languageId), cusShipTotal));
}
//payment method fee
if (displayPaymentMethodFee)
{
string paymentMethodFeeTitle = _localizationService.GetResource("Messages.Order.PaymentMethodAdditionalFee", languageId);
sb.AppendLine(string.Format("<tr style=\"text-align:right;\"><td> </td><td colspan=\"2\" style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{1}</strong></td> <td style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{2}</strong></td></tr>", _templatesSettings.Color3, paymentMethodFeeTitle, cusPaymentMethodAdditionalFee));
}
//tax
if (displayTax)
{
sb.AppendLine(string.Format("<tr style=\"text-align:right;\"><td> </td><td colspan=\"2\" style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{1}</strong></td> <td style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{2}</strong></td></tr>", _templatesSettings.Color3, _localizationService.GetResource("Messages.Order.Tax", languageId), cusTaxTotal));
}
if (displayTaxRates)
{
foreach (var item in taxRates)
{
string taxRate = String.Format(_localizationService.GetResource("Messages.Order.TaxRateLine"), _priceFormatter.FormatTaxRate(item.Key));
string taxValue = _priceFormatter.FormatPrice(item.Value, true, order.CustomerCurrencyCode, false, language);
sb.AppendLine(string.Format("<tr style=\"text-align:right;\"><td> </td><td colspan=\"2\" style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{1}</strong></td> <td style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{2}</strong></td></tr>", _templatesSettings.Color3, taxRate, taxValue));
}
}
//discount
if (dislayDiscount)
{
sb.AppendLine(string.Format("<tr style=\"text-align:right;\"><td> </td><td colspan=\"2\" style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{1}</strong></td> <td style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{2}</strong></td></tr>", _templatesSettings.Color3, _localizationService.GetResource("Messages.Order.TotalDiscount", languageId), cusDiscount));
}
//gift cards
var gcuhC = order.GiftCardUsageHistory;
foreach (var gcuh in gcuhC)
{
string giftCardText = String.Format(_localizationService.GetResource("Messages.Order.GiftCardInfo", languageId), HttpUtility.HtmlEncode(gcuh.GiftCard.GiftCardCouponCode));
string giftCardAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, language);
sb.AppendLine(string.Format("<tr style=\"text-align:right;\"><td> </td><td colspan=\"2\" style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{1}</strong></td> <td style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{2}</strong></td></tr>", _templatesSettings.Color3, giftCardText, giftCardAmount));
}
//reward points
if (order.RedeemedRewardPointsEntry != null)
{
string rpTitle = string.Format(_localizationService.GetResource("Messages.Order.RewardPoints", languageId), -order.RedeemedRewardPointsEntry.Points);
string rpAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(order.RedeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, language);
sb.AppendLine(string.Format("<tr style=\"text-align:right;\"><td> </td><td colspan=\"2\" style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{1}</strong></td> <td style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{2}</strong></td></tr>", _templatesSettings.Color3, rpTitle, rpAmount));
}
//total
sb.AppendLine(string.Format("<tr style=\"text-align:right;\"><td> </td><td colspan=\"2\" style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{1}</strong></td> <td style=\"background-color: {0};padding:0.6em 0.4 em;\"><strong>{2}</strong></td></tr>", _templatesSettings.Color3, _localizationService.GetResource("Messages.Order.OrderTotal", languageId), cusTotal));
#endregion
sb.AppendLine("</table>");
result = sb.ToString();
return(result);
}
/// <summary>
/// PrepareOrderTotalsModel:
/// </summary>
/// <param name="cart"></param>
/// <param name="isEditable"></param>
/// <returns></returns>
public virtual decimal PrepareOrderTotalsModel(IList <ShoppingCartItem> cart, bool isEditable)
{
var model = new OrderTotalsModel();
model.IsEditable = isEditable;
if (cart.Count > 0)
{
//subtotal
decimal orderSubTotalDiscountAmountBase;
Discount orderSubTotalAppliedDiscount;
decimal subTotalWithoutDiscountBase;
decimal subTotalWithDiscountBase;
var subTotalIncludingTax = _workContext.TaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal;
_orderTotalCalculationService.GetShoppingCartSubTotal(cart, subTotalIncludingTax,
out orderSubTotalDiscountAmountBase, out orderSubTotalAppliedDiscount,
out subTotalWithoutDiscountBase, out subTotalWithDiscountBase);
decimal subtotalBase = subTotalWithoutDiscountBase;
decimal subtotal = _currencyService.ConvertFromPrimaryStoreCurrency(subtotalBase, _workContext.WorkingCurrency);
model.SubTotal = _priceFormatter.FormatPrice(subtotal, true, _workContext.WorkingCurrency, _workContext.WorkingLanguage, subTotalIncludingTax);
if (orderSubTotalDiscountAmountBase > decimal.Zero)
{
decimal orderSubTotalDiscountAmount = _currencyService.ConvertFromPrimaryStoreCurrency(orderSubTotalDiscountAmountBase, _workContext.WorkingCurrency);
model.SubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountAmount, true, _workContext.WorkingCurrency, _workContext.WorkingLanguage, subTotalIncludingTax);
model.AllowRemovingSubTotalDiscount = orderSubTotalAppliedDiscount != null &&
orderSubTotalAppliedDiscount.RequiresCouponCode &&
!String.IsNullOrEmpty(orderSubTotalAppliedDiscount.CouponCode) &&
model.IsEditable;
}
//shipping info
model.RequiresShipping = cart.RequiresShipping();
if (model.RequiresShipping)
{
decimal?shoppingCartShippingBase = _orderTotalCalculationService.GetShoppingCartShippingTotal(cart);
if (shoppingCartShippingBase.HasValue)
{
decimal shoppingCartShipping = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartShippingBase.Value, _workContext.WorkingCurrency);
model.Shipping = _priceFormatter.FormatShippingPrice(shoppingCartShipping, true);
//selected shipping method
var shippingOption = _workContext.CurrentCustomer.GetAttribute <ShippingOption>(SystemCustomerAttributeNames.SelectedShippingOption, _storeContext.CurrentStore.Id);
if (shippingOption != null)
{
model.SelectedShippingMethod = shippingOption.Name;
}
}
}
//payment method fee
var paymentMethodSystemName = _workContext.CurrentCustomer.GetAttribute <string>(
SystemCustomerAttributeNames.SelectedPaymentMethod, _storeContext.CurrentStore.Id);
decimal paymentMethodAdditionalFee = _paymentService.GetAdditionalHandlingFee(cart, paymentMethodSystemName);
decimal paymentMethodAdditionalFeeWithTaxBase = _taxService.GetPaymentMethodAdditionalFee(paymentMethodAdditionalFee, _workContext.CurrentCustomer);
if (paymentMethodAdditionalFeeWithTaxBase > decimal.Zero)
{
decimal paymentMethodAdditionalFeeWithTax = _currencyService.ConvertFromPrimaryStoreCurrency(paymentMethodAdditionalFeeWithTaxBase, _workContext.WorkingCurrency);
model.PaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeWithTax, true);
}
//tax
bool displayTax = true;
bool displayTaxRates = true;
if (_taxSettings.HideTaxInOrderSummary && _workContext.TaxDisplayType == TaxDisplayType.IncludingTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
SortedDictionary <decimal, decimal> taxRates;
decimal shoppingCartTaxBase = _orderTotalCalculationService.GetTaxTotal(cart, out taxRates);
decimal shoppingCartTax = _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartTaxBase, _workContext.WorkingCurrency);
if (shoppingCartTaxBase == 0 && _taxSettings.HideZeroTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
displayTaxRates = _taxSettings.DisplayTaxRates && taxRates.Count > 0;
displayTax = !displayTaxRates;
model.Tax = _priceFormatter.FormatPrice(shoppingCartTax, true, false);
foreach (var tr in taxRates)
{
model.TaxRates.Add(new OrderTotalsModel.TaxRate
{
Rate = _priceFormatter.FormatTaxRate(tr.Key),
Value = _priceFormatter.FormatPrice(_currencyService.ConvertFromPrimaryStoreCurrency(tr.Value, _workContext.WorkingCurrency), true, false),
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
//total
decimal orderTotalDiscountAmountBase;
Discount orderTotalAppliedDiscount;
List <AppliedGiftCard> appliedGiftCards;
int redeemedRewardPoints;
decimal redeemedRewardPointsAmount;
decimal?shoppingCartTotalBase = _orderTotalCalculationService.GetShoppingCartTotal(cart,
out orderTotalDiscountAmountBase, out orderTotalAppliedDiscount,
out appliedGiftCards, out redeemedRewardPoints, out redeemedRewardPointsAmount);
return(_currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartTotalBase.Value, _workContext.WorkingCurrency));
}
return(decimal.Zero);
}
public async Task AddOrderTokens(LiquidObject liquidObject, Order order, Customer customer, Store store, OrderNote orderNote = null, string vendorId = "", decimal refundedAmount = 0)
{
var language = await _languageService.GetLanguageById(order.CustomerLanguageId);
var currency = await _currencyService.GetCurrencyByCode(order.CustomerCurrencyCode);
var productService = _serviceProvider.GetRequiredService <IProductService>();
var downloadService = _serviceProvider.GetRequiredService <IDownloadService>();
var liquidOrder = new LiquidOrder(order, customer, language, currency, store, orderNote, vendorId);
foreach (var item in order.OrderItems)
{
var product = await productService.GetProductById(item.ProductId);
var liqitem = new LiquidOrderItem(item, product, order, language, currency, store);
#region Download
liqitem.IsDownloadAllowed = await downloadService.IsDownloadAllowed(item);
liqitem.IsLicenseDownloadAllowed = await downloadService.IsLicenseDownloadAllowed(item);
#endregion
#region Unit price
string unitPriceStr;
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(item.UnitPriceInclTax, order.CurrencyRate);
unitPriceStr = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, currency, language, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(item.UnitPriceExclTax, order.CurrencyRate);
unitPriceStr = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, currency, language, false);
}
liqitem.UnitPrice = unitPriceStr;
#endregion
#region total price
string priceStr;
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(item.PriceInclTax, order.CurrencyRate);
priceStr = _priceFormatter.FormatPrice(priceInclTaxInCustomerCurrency, true, currency, language, true);
}
else
{
//excluding tax
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(item.PriceExclTax, order.CurrencyRate);
priceStr = _priceFormatter.FormatPrice(priceExclTaxInCustomerCurrency, true, currency, language, false);
}
liqitem.TotalPrice = priceStr;
#endregion
string sku = "";
if (product != null)
{
sku = product.FormatSku(item.AttributesXml, _productAttributeParser);
}
liqitem.ProductSku = WebUtility.HtmlEncode(sku);
liqitem.ShowSkuOnProductDetailsPage = _catalogSettings.ShowSkuOnProductDetailsPage;
liqitem.ProductOldPrice = _priceFormatter.FormatPrice(product.OldPrice, true, currency, language, true);
liquidOrder.OrderItems.Add(liqitem);
}
liquidOrder.BillingCustomAttributes = await _addressAttributeFormatter.FormatAttributes(order.BillingAddress?.CustomAttributes);
liquidOrder.BillingCountry = order.BillingAddress != null && !string.IsNullOrEmpty(order.BillingAddress.CountryId) ? (await _countryService.GetCountryById(order.BillingAddress.CountryId))?.GetLocalized(x => x.Name, order.CustomerLanguageId) : "";
liquidOrder.BillingStateProvince = !string.IsNullOrEmpty(order.BillingAddress.StateProvinceId) ? (await _stateProvinceService.GetStateProvinceById(order.BillingAddress.StateProvinceId))?.GetLocalized(x => x.Name, order.CustomerLanguageId) : "";
liquidOrder.ShippingCountry = order.ShippingAddress != null && !string.IsNullOrEmpty(order.ShippingAddress.CountryId) ? (await _countryService.GetCountryById(order.ShippingAddress.CountryId))?.GetLocalized(x => x.Name, order.CustomerLanguageId) : "";
liquidOrder.ShippingStateProvince = order.ShippingAddress != null && !string.IsNullOrEmpty(order.ShippingAddress.StateProvinceId) ? (await _stateProvinceService.GetStateProvinceById(order.ShippingAddress.StateProvinceId)).GetLocalized(x => x.Name, order.CustomerLanguageId) : "";
liquidOrder.ShippingCustomAttributes = await _addressAttributeFormatter.FormatAttributes(order.ShippingAddress != null?order.ShippingAddress.CustomAttributes : "");
var paymentMethod = _serviceProvider.GetRequiredService <IPaymentService>().LoadPaymentMethodBySystemName(order.PaymentMethodSystemName);
liquidOrder.PaymentMethod = paymentMethod != null?paymentMethod.GetLocalizedFriendlyName(_localizationService, language.Id) : order.PaymentMethodSystemName;
liquidOrder.AmountRefunded = _priceFormatter.FormatPrice(refundedAmount, true, currency, language, false);
Dictionary <string, string> dict = new Dictionary <string, string>();
foreach (var item in order.TaxRatesDictionary)
{
string taxRate = string.Format(_localizationService.GetResource("Messages.Order.TaxRateLine"), _priceFormatter.FormatTaxRate(item.Key));
string taxValue = _priceFormatter.FormatPrice(item.Value, true, currency, language, false);
dict.Add(taxRate, taxValue);
}
liquidOrder.TaxRates = dict;
Dictionary <string, string> cards = new Dictionary <string, string>();
var servicegiftCard = _serviceProvider.GetRequiredService <IGiftCardService>();
var gcuhC = await servicegiftCard.GetAllGiftCardUsageHistory(order.Id);
foreach (var gcuh in gcuhC)
{
var giftCard = await servicegiftCard.GetGiftCardById(gcuh.GiftCardId);
string giftCardText = string.Format(_localizationService.GetResource("Messages.Order.GiftCardInfo", language.Id), WebUtility.HtmlEncode(giftCard.GiftCardCouponCode));
string giftCardAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, currency, language, false);
cards.Add(giftCardText, giftCardAmount);
}
liquidOrder.GiftCards = cards;
if (order.RedeemedRewardPointsEntry != null)
{
liquidOrder.RPTitle = string.Format(_localizationService.GetResource("Messages.Order.RewardPoints", language.Id), -order.RedeemedRewardPointsEntry?.Points);
liquidOrder.RPAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(order.RedeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)), true, currency, language, false);
}
void CalculateSubTotals()
{
string _cusSubTotal;
bool _displaySubTotalDiscount;
string _cusSubTotalDiscount;
string _cusShipTotal;
string _cusPaymentMethodAdditionalFee;
bool _displayTax;
string _cusTaxTotal;
bool _displayTaxRates;
bool _displayDiscount;
string _cusDiscount;
string _cusTotal;
_displaySubTotalDiscount = false;
_cusSubTotalDiscount = string.Empty;
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal)
{
//including tax
//subtotal
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
_cusSubTotal = _priceFormatter.FormatPrice(orderSubtotalInclTaxInCustomerCurrency, true, currency, language, true);
//discount (applied to order subtotal)
var orderSubTotalDiscountInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountInclTax, order.CurrencyRate);
if (orderSubTotalDiscountInclTaxInCustomerCurrency > decimal.Zero)
{
_cusSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, currency, language, true);
_displaySubTotalDiscount = true;
}
}
else
{
//exсluding tax
//subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
_cusSubTotal = _priceFormatter.FormatPrice(orderSubtotalExclTaxInCustomerCurrency, true, currency, language, false);
//discount (applied to order subtotal)
var orderSubTotalDiscountExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountExclTax, order.CurrencyRate);
if (orderSubTotalDiscountExclTaxInCustomerCurrency > decimal.Zero)
{
_cusSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, currency, language, false);
_displaySubTotalDiscount = true;
}
}
//shipping, payment method fee
_cusTaxTotal = string.Empty;
_cusDiscount = string.Empty;
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
//shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
_cusShipTotal = _priceFormatter.FormatShippingPrice(orderShippingInclTaxInCustomerCurrency, true, currency, language, true);
//payment method additional fee
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
_cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, currency, language, true);
}
else
{
//excluding tax
//shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
_cusShipTotal = _priceFormatter.FormatShippingPrice(orderShippingExclTaxInCustomerCurrency, true, currency, language, false);
//payment method additional fee
var paymentMethodAdditionalFeeExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate);
_cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, currency, language, false);
}
//shipping
bool displayShipping = order.ShippingStatus != ShippingStatus.ShippingNotRequired;
//payment method fee
bool displayPaymentMethodFee = order.PaymentMethodAdditionalFeeExclTax > decimal.Zero;
//tax
_displayTax = true;
_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 = new SortedDictionary <decimal, decimal>();
foreach (var tr in order.TaxRatesDictionary)
{
_taxRates.Add(tr.Key, _currencyService.ConvertCurrency(tr.Value, order.CurrencyRate));
}
_displayTaxRates = _taxSettings.DisplayTaxRates && _taxRates.Any();
_displayTax = !_displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
string taxStr = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, currency, language, order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
_cusTaxTotal = taxStr;
}
}
//discount
_displayDiscount = false;
if (order.OrderDiscount > decimal.Zero)
{
var orderDiscountInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderDiscount, order.CurrencyRate);
_cusDiscount = _priceFormatter.FormatPrice(-orderDiscountInCustomerCurrency, true, currency, language, order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
_displayDiscount = true;
}
//total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
_cusTotal = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, currency, language, order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
liquidOrder.SubTotal = _cusSubTotal;
liquidOrder.DisplaySubTotalDiscount = _displaySubTotalDiscount;
liquidOrder.SubTotalDiscount = _cusSubTotalDiscount;
liquidOrder.Shipping = _cusShipTotal;
liquidOrder.Tax = _cusTaxTotal;
liquidOrder.Total = _cusTotal;
liquidOrder.DisplayDiscount = _displayDiscount;
liquidOrder.DisplayTaxRates = _displayTaxRates;
}
CalculateSubTotals();
liquidObject.Order = liquidOrder;
await _mediator.EntityTokensAdded(order, liquidOrder, liquidObject);
}
/// <summary>
/// Prepare the order details model
/// </summary>
/// <param name="order">Order</param>
/// <returns>Order details model</returns>
public virtual OrderDetailsModel PrepareOrderDetailsModel(Order order)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
var model = new OrderDetailsModel
{
Id = order.Id,
CreatedOn = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc),
OrderStatus = _localizationService.GetLocalizedEnum(order.OrderStatus),
IsReOrderAllowed = _orderSettings.IsReOrderAllowed,
IsReturnRequestAllowed = _orderProcessingService.IsReturnRequestAllowed(order),
PdfInvoiceDisabled = _pdfSettings.DisablePdfInvoicesForPendingOrders && order.OrderStatus == OrderStatus.Pending,
CustomOrderNumber = order.CustomOrderNumber,
//shipping info
ShippingStatus = _localizationService.GetLocalizedEnum(order.ShippingStatus)
};
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.PickupInStore = order.PickupInStore;
if (!order.PickupInStore)
{
var shippingAddress = _addressService.GetAddressById(order.ShippingAddressId ?? 0);
_addressModelFactory.PrepareAddressModel(model.ShippingAddress,
address: shippingAddress,
excludeProperties: false,
addressSettings: _addressSettings);
}
else if (order.PickupAddressId.HasValue && _addressService.GetAddressById(order.PickupAddressId.Value) is Address pickupAddress)
{
model.PickupAddress = new AddressModel
{
Address1 = pickupAddress.Address1,
City = pickupAddress.City,
County = pickupAddress.County,
CountryName = _countryService.GetCountryByAddress(pickupAddress)?.Name ?? string.Empty,
ZipPostalCode = pickupAddress.ZipPostalCode
};
}
model.ShippingMethod = order.ShippingMethod;
//shipments (only already shipped)
var shipments = _shipmentService.GetShipmentsByOrderId(order.Id, true).OrderBy(x => x.CreatedOnUtc).ToList();
foreach (var shipment in shipments)
{
var shipmentModel = new OrderDetailsModel.ShipmentBriefModel
{
Id = shipment.Id,
TrackingNumber = shipment.TrackingNumber,
};
if (shipment.ShippedDateUtc.HasValue)
{
shipmentModel.ShippedDate = _dateTimeHelper.ConvertToUserTime(shipment.ShippedDateUtc.Value, DateTimeKind.Utc);
}
if (shipment.DeliveryDateUtc.HasValue)
{
shipmentModel.DeliveryDate = _dateTimeHelper.ConvertToUserTime(shipment.DeliveryDateUtc.Value, DateTimeKind.Utc);
}
model.Shipments.Add(shipmentModel);
}
}
var billingAddress = _addressService.GetAddressById(order.BillingAddressId);
//billing info
_addressModelFactory.PrepareAddressModel(model.BillingAddress,
address: billingAddress,
excludeProperties: false,
addressSettings: _addressSettings);
//VAT number
model.VatNumber = order.VatNumber;
var languageId = _workContext.WorkingLanguage.Id;
//payment method
var customer = _customerService.GetCustomerById(order.CustomerId);
var paymentMethod = _paymentPluginManager
.LoadPluginBySystemName(order.PaymentMethodSystemName, customer, order.StoreId);
model.PaymentMethod = paymentMethod != null?_localizationService.GetLocalizedFriendlyName(paymentMethod, languageId) : order.PaymentMethodSystemName;
model.PaymentMethodStatus = _localizationService.GetLocalizedEnum(order.PaymentStatus);
model.CanRePostProcessPayment = _paymentService.CanRePostProcessPayment(order);
//custom values
model.CustomValues = _paymentService.DeserializeCustomValues(order);
//order subtotal
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal)
{
//including tax
//order subtotal
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
model.OrderSubtotal = _priceFormatter.FormatPrice(orderSubtotalInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
//discount (applied to order subtotal)
var orderSubTotalDiscountInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountInclTax, order.CurrencyRate);
if (orderSubTotalDiscountInclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
}
}
else
{
//excluding tax
//order subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = _priceFormatter.FormatPrice(orderSubtotalExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
//discount (applied to order subtotal)
var orderSubTotalDiscountExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountExclTax, order.CurrencyRate);
if (orderSubTotalDiscountExclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
}
}
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
//order shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
model.OrderShipping = _priceFormatter.FormatShippingPrice(orderShippingInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
//payment method additional fee
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeInclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
}
}
else
{
//excluding tax
//order shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = _priceFormatter.FormatShippingPrice(orderShippingExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
//payment method additional fee
var paymentMethodAdditionalFeeExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeExclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
}
}
//tax
var displayTax = true;
var displayTaxRates = true;
if (_taxSettings.HideTaxInOrderSummary && order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
if (order.OrderTax == 0 && _taxSettings.HideZeroTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
var taxRates = _orderService.ParseTaxRates(order, order.TaxRates);
displayTaxRates = _taxSettings.DisplayTaxRates && taxRates.Any();
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
model.Tax = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
foreach (var tr in taxRates)
{
model.TaxRates.Add(new OrderDetailsModel.TaxRate
{
Rate = _priceFormatter.FormatTaxRate(tr.Key),
Value = _priceFormatter.FormatPrice(_currencyService.ConvertCurrency(tr.Value, order.CurrencyRate), true, order.CustomerCurrencyCode, false, languageId),
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
model.DisplayTaxShippingInfo = _catalogSettings.DisplayTaxShippingInfoOrderDetailsPage;
model.PricesIncludeTax = order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax;
//discount (applied to order total)
var orderDiscountInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderDiscount, order.CurrencyRate);
if (orderDiscountInCustomerCurrency > decimal.Zero)
{
model.OrderTotalDiscount = _priceFormatter.FormatPrice(-orderDiscountInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
}
//gift cards
foreach (var gcuh in _giftCardService.GetGiftCardUsageHistory(order))
{
model.GiftCards.Add(new OrderDetailsModel.GiftCard
{
CouponCode = _giftCardService.GetGiftCardById(gcuh.GiftCardId).GiftCardCouponCode,
Amount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, languageId),
});
}
//reward points
if (order.RedeemedRewardPointsEntryId.HasValue && _rewardPointService.GetRewardPointsHistoryEntryById(order.RedeemedRewardPointsEntryId.Value) is RewardPointsHistory redeemedRewardPointsEntry)
{
model.RedeemedRewardPoints = -redeemedRewardPointsEntry.Points;
model.RedeemedRewardPointsAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(redeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, languageId);
}
//total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
model.OrderTotal = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
//checkout attributes
model.CheckoutAttributeInfo = order.CheckoutAttributeDescription;
//order notes
foreach (var orderNote in _orderService.GetOrderNotesByOrderId(order.Id, true)
.OrderByDescending(on => on.CreatedOnUtc)
.ToList())
{
model.OrderNotes.Add(new OrderDetailsModel.OrderNote
{
Id = orderNote.Id,
HasDownload = orderNote.DownloadId > 0,
Note = _orderService.FormatOrderNoteText(orderNote),
CreatedOn = _dateTimeHelper.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc)
});
}
//purchased products
model.ShowSku = _catalogSettings.ShowSkuOnProductDetailsPage;
model.ShowVendorName = _vendorSettings.ShowVendorOnOrderDetailsPage;
var orderItems = _orderService.GetOrderItems(order.Id);
foreach (var orderItem in orderItems)
{
var product = _productService.GetProductById(orderItem.ProductId);
var orderItemModel = new OrderDetailsModel.OrderItemModel
{
Id = orderItem.Id,
OrderItemGuid = orderItem.OrderItemGuid,
Sku = _productService.FormatSku(product, orderItem.AttributesXml),
VendorName = _vendorService.GetVendorById(product.VendorId)?.Name ?? string.Empty,
ProductId = product.Id,
ProductName = _localizationService.GetLocalized(product, x => x.Name),
ProductSeName = _urlRecordService.GetSeName(product),
Quantity = orderItem.Quantity,
AttributeInfo = orderItem.AttributeDescription,
};
//rental info
if (product.IsRental)
{
var rentalStartDate = orderItem.RentalStartDateUtc.HasValue
? _productService.FormatRentalDate(product, orderItem.RentalStartDateUtc.Value) : "";
var rentalEndDate = orderItem.RentalEndDateUtc.HasValue
? _productService.FormatRentalDate(product, orderItem.RentalEndDateUtc.Value) : "";
orderItemModel.RentalInfo = string.Format(_localizationService.GetResource("Order.Rental.FormattedDate"),
rentalStartDate, rentalEndDate);
}
model.Items.Add(orderItemModel);
//unit price, subtotal
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
}
//downloadable products
if (_orderService.IsDownloadAllowed(orderItem))
{
orderItemModel.DownloadId = product.DownloadId;
}
if (_orderService.IsLicenseDownloadAllowed(orderItem))
{
orderItemModel.LicenseId = orderItem.LicenseDownloadId ?? 0;
}
}
return(model);
}
public async Task <CheckoutShippingMethodModel> Handle(GetShippingMethod request, CancellationToken cancellationToken)
{
var model = new CheckoutShippingMethodModel();
var getShippingOptionResponse = await _shippingService
.GetShippingOptions(request.Customer, request.Cart, request.ShippingAddress,
"", request.Store);
if (getShippingOptionResponse.Success)
{
//performance optimization. cache returned shipping options.
//we'll use them later (after a customer has selected an option).
await _genericAttributeService.SaveAttribute(request.Customer,
SystemCustomerAttributeNames.OfferedShippingOptions,
getShippingOptionResponse.ShippingOptions,
request.Store.Id);
foreach (var shippingOption in getShippingOptionResponse.ShippingOptions)
{
var soModel = new CheckoutShippingMethodModel.ShippingMethodModel {
Name = shippingOption.Name,
Description = shippingOption.Description,
ShippingRateComputationMethodSystemName = shippingOption.ShippingRateComputationMethodSystemName,
ShippingOption = shippingOption,
};
//adjust rate
var shippingTotal = (await _orderTotalCalculationService.AdjustShippingRate(
shippingOption.Rate, request.Cart)).shippingRate;
decimal rateBase = (await _taxService.GetShippingPrice(shippingTotal, request.Customer)).shippingPrice;
decimal rate = await _currencyService.ConvertFromPrimaryStoreCurrency(rateBase, request.Currency);
soModel.Fee = _priceFormatter.FormatShippingPrice(rate, true);
model.ShippingMethods.Add(soModel);
}
//find a selected (previously) shipping method
var selectedShippingOption = request.Customer.GetAttributeFromEntity <ShippingOption>(SystemCustomerAttributeNames.SelectedShippingOption, request.Store.Id);
if (selectedShippingOption != null)
{
var shippingOptionToSelect = model.ShippingMethods.ToList()
.Find(so =>
!String.IsNullOrEmpty(so.Name) &&
so.Name.Equals(selectedShippingOption.Name, StringComparison.OrdinalIgnoreCase) &&
!String.IsNullOrEmpty(so.ShippingRateComputationMethodSystemName) &&
so.ShippingRateComputationMethodSystemName.Equals(selectedShippingOption.ShippingRateComputationMethodSystemName, StringComparison.OrdinalIgnoreCase));
if (shippingOptionToSelect != null)
{
shippingOptionToSelect.Selected = true;
}
}
//if no option has been selected, let's do it for the first one
if (model.ShippingMethods.FirstOrDefault(so => so.Selected) == null)
{
var shippingOptionToSelect = model.ShippingMethods.FirstOrDefault();
if (shippingOptionToSelect != null)
{
shippingOptionToSelect.Selected = true;
}
}
//notify about shipping from multiple locations
if (_shippingSettings.NotifyCustomerAboutShippingFromMultipleLocations)
{
model.NotifyCustomerAboutShippingFromMultipleLocations = getShippingOptionResponse.ShippingFromMultipleLocations;
}
}
else
{
foreach (var error in getShippingOptionResponse.Errors)
{
model.Warnings.Add(error);
}
}
return(model);
}
public virtual async Task <CheckoutShippingAddressModel> PrepareShippingAddress(string selectedCountryId = null,
bool prePopulateNewAddressWithCustomerFields = false, string overrideAttributesXml = "")
{
var model = new CheckoutShippingAddressModel();
//allow pickup in store?
model.AllowPickUpInStore = _shippingSettings.AllowPickUpInStore;
if (model.AllowPickUpInStore)
{
var pickupPoints = await _shippingService.LoadActivePickupPoints(_storeContext.CurrentStore.Id);
if (pickupPoints.Any())
{
foreach (var pickupPoint in pickupPoints)
{
var pickupPointModel = new CheckoutPickupPointModel()
{
Id = pickupPoint.Id,
Name = pickupPoint.Name,
Description = pickupPoint.Description,
Address = pickupPoint.Address,
};
if (pickupPoint.PickupFee > 0)
{
var amount = (await _taxService.GetShippingPrice(pickupPoint.PickupFee, _workContext.CurrentCustomer)).shippingPrice;
amount = await _currencyService.ConvertFromPrimaryStoreCurrency(amount, _workContext.WorkingCurrency);
pickupPointModel.PickupFee = _priceFormatter.FormatShippingPrice(amount, true);
}
model.PickupPoints.Add(pickupPointModel);
}
}
if (!(await _shippingService.LoadActiveShippingRateComputationMethods(_storeContext.CurrentStore.Id)).Any())
{
if (!pickupPoints.Any())
{
model.Warnings.Add(_localizationService.GetResource("Checkout.ShippingIsNotAllowed"));
model.Warnings.Add(_localizationService.GetResource("Checkout.PickupPoints.NotAvailable"));
}
model.PickUpInStoreOnly = true;
model.PickUpInStore = true;
return(model);
}
}
//existing addresses
var addresses = new List <Address>();
foreach (var item in _workContext.CurrentCustomer.Addresses)
{
if (string.IsNullOrEmpty(item.CountryId))
{
addresses.Add(item);
continue;
}
var country = await _countryService.GetCountryById(item.CountryId);
if (country == null || (country.AllowsShipping && _storeMappingService.Authorize(country)))
{
addresses.Add(item);
continue;
}
}
foreach (var address in addresses)
{
var addressModel = new AddressModel();
await _addressViewModelService.PrepareModel(model : addressModel,
address : address,
excludeProperties : false);
model.ExistingAddresses.Add(addressModel);
}
//new address
model.NewAddress.CountryId = selectedCountryId;
var countries = await _countryService.GetAllCountriesForShipping();
await _addressViewModelService.PrepareModel(model : model.NewAddress,
address : null,
excludeProperties : false,
loadCountries : () => countries,
prePopulateWithCustomerFields : prePopulateNewAddressWithCustomerFields,
customer : _workContext.CurrentCustomer,
overrideAttributesXml : overrideAttributesXml);
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);
}
public virtual CheckoutShippingAddressModel PrepareShippingAddress(string selectedCountryId = null,
bool prePopulateNewAddressWithCustomerFields = false, string overrideAttributesXml = "")
{
var model = new CheckoutShippingAddressModel();
//allow pickup in store?
model.AllowPickUpInStore = _shippingSettings.AllowPickUpInStore;
if (model.AllowPickUpInStore)
{
var pickupPoints = _shippingService.LoadActivePickupPoints(_storeContext.CurrentStore.Id);
if (pickupPoints.Any())
{
model.PickupPoints = pickupPoints.Select(x =>
{
var pickupPointModel = new CheckoutPickupPointModel()
{
Id = x.Id,
Name = x.Name,
Description = x.Description,
Address = x.Address,
};
if (x.PickupFee > 0)
{
var amount = _taxService.GetShippingPrice(x.PickupFee, _workContext.CurrentCustomer);
amount = _currencyService.ConvertFromPrimaryStoreCurrency(amount, _workContext.WorkingCurrency);
pickupPointModel.PickupFee = _priceFormatter.FormatShippingPrice(amount, true);
}
return(pickupPointModel);
}).ToList();
}
if (!_shippingService.LoadActiveShippingRateComputationMethods(_storeContext.CurrentStore.Id).Any())
{
if (!pickupPoints.Any())
{
model.Warnings.Add(_localizationService.GetResource("Checkout.ShippingIsNotAllowed"));
model.Warnings.Add(_localizationService.GetResource("Checkout.PickupPoints.NotAvailable"));
}
model.PickUpInStoreOnly = true;
model.PickUpInStore = true;
return(model);
}
}
//existing addresses
var addresses = _workContext.CurrentCustomer.Addresses
//allow shipping
.Where(a => a.CountryId == "" ||
(_countryService.GetCountryById(a.CountryId) != null ? _countryService.GetCountryById(a.CountryId).AllowsShipping : false)
//a.Country.AllowsShipping
)
//enabled for the current store
.Where(a => a.CountryId == "" ||
_storeMappingService.Authorize(_countryService.GetCountryById(a.CountryId)))
.ToList();
foreach (var address in addresses)
{
var addressModel = new AddressModel();
_addressViewModelService.PrepareModel(model: addressModel,
address: address,
excludeProperties: false);
model.ExistingAddresses.Add(addressModel);
}
//new address
model.NewAddress.CountryId = selectedCountryId;
_addressViewModelService.PrepareModel(model: model.NewAddress,
address: null,
excludeProperties: false,
loadCountries: () => _countryService.GetAllCountriesForShipping(),
prePopulateWithCustomerFields: prePopulateNewAddressWithCustomerFields,
customer: _workContext.CurrentCustomer,
overrideAttributesXml: overrideAttributesXml);
return(model);
}
/// <summary>
/// Prepare shipping address model
/// </summary>
/// <param name="selectedCountryId">Selected country identifier</param>
/// <param name="prePopulateNewAddressWithCustomerFields">Pre populate new address with customer fields</param>
/// <param name="overrideAttributesXml">Override attributes xml</param>
/// <returns>Shipping address model</returns>
public virtual CheckoutShippingAddressModel PrepareShippingAddressModel(int?selectedCountryId = null,
bool prePopulateNewAddressWithCustomerFields = false, string overrideAttributesXml = "")
{
var model = new CheckoutShippingAddressModel();
//allow pickup in store?
model.AllowPickUpInStore = _shippingSettings.AllowPickUpInStore;
if (model.AllowPickUpInStore)
{
model.DisplayPickupPointsOnMap = _shippingSettings.DisplayPickupPointsOnMap;
model.GoogleMapsApiKey = _shippingSettings.GoogleMapsApiKey;
var pickupPointProviders = _shippingService.LoadActivePickupPointProviders(_workContext.CurrentCustomer, _storeContext.CurrentStore.Id);
if (pickupPointProviders.Any())
{
var pickupPointsResponse = _shippingService.GetPickupPoints(_workContext.CurrentCustomer.BillingAddress,
_workContext.CurrentCustomer, storeId: _storeContext.CurrentStore.Id);
if (pickupPointsResponse.Success)
{
model.PickupPoints = pickupPointsResponse.PickupPoints.Select(x =>
{
var country = _countryService.GetCountryByTwoLetterIsoCode(x.CountryCode);
var state = _stateProvinceService.GetStateProvinceByAbbreviation(x.StateAbbreviation);
var pickupPointModel = new CheckoutPickupPointModel
{
Id = x.Id,
Name = x.Name,
Description = x.Description,
ProviderSystemName = x.ProviderSystemName,
Address = x.Address,
City = x.City,
StateName = state != null ? state.Name : string.Empty,
CountryName = country != null ? country.Name : string.Empty,
ZipPostalCode = x.ZipPostalCode,
Latitude = x.Latitude,
Longitude = x.Longitude,
OpeningHours = x.OpeningHours
};
if (x.PickupFee > 0)
{
var amount = _taxService.GetShippingPrice(x.PickupFee, _workContext.CurrentCustomer);
amount = _currencyService.ConvertFromPrimaryStoreCurrency(amount, _workContext.WorkingCurrency);
pickupPointModel.PickupFee = _priceFormatter.FormatShippingPrice(amount, true);
}
return(pickupPointModel);
}).ToList();
}
else
{
foreach (var error in pickupPointsResponse.Errors)
{
model.Warnings.Add(error);
}
}
}
//only available pickup points
if (!_shippingService.LoadActiveShippingRateComputationMethods(_workContext.CurrentCustomer, _storeContext.CurrentStore.Id).Any())
{
if (!pickupPointProviders.Any())
{
model.Warnings.Add(_localizationService.GetResource("Checkout.ShippingIsNotAllowed"));
model.Warnings.Add(_localizationService.GetResource("Checkout.PickupPoints.NotAvailable"));
}
model.PickUpInStoreOnly = true;
model.PickUpInStore = true;
return(model);
}
}
//existing addresses
var addresses = _workContext.CurrentCustomer.Addresses
.Where(a => a.Country == null ||
(//published
a.Country.Published &&
//allow shipping
a.Country.AllowsShipping &&
//enabled for the current store
_storeMappingService.Authorize(a.Country)))
.ToList();
foreach (var address in addresses)
{
var addressModel = new AddressModel();
_addressModelFactory.PrepareAddressModel(addressModel,
address: address,
excludeProperties: false,
addressSettings: _addressSettings);
model.ExistingAddresses.Add(addressModel);
}
//new address
model.NewAddress.CountryId = selectedCountryId;
_addressModelFactory.PrepareAddressModel(model.NewAddress,
address: null,
excludeProperties: false,
addressSettings: _addressSettings,
loadCountries: () => _countryService.GetAllCountriesForShipping(_workContext.WorkingLanguage.Id),
prePopulateWithCustomerFields: prePopulateNewAddressWithCustomerFields,
customer: _workContext.CurrentCustomer,
overrideAttributesXml: overrideAttributesXml);
return(model);
}
private 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.Status = order.OrderStatus;
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.Shipped)
{
model.OrderStatus = model.ShippingStatus;
}
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;
}
if (order.ShippedDateUtc.HasValue)
{
model.ShippedDate = _dateTimeHelper.ConvertToUserTime(order.ShippedDateUtc.Value, DateTimeKind.Utc).ToString("D");
}
if (order.DeliveryDateUtc.HasValue)
{
model.DeliveryDate = _dateTimeHelper.ConvertToUserTime(order.DeliveryDateUtc.Value, DateTimeKind.Utc).ToString("D");
}
model.TrackingNumber = order.TrackingNumber;
model.TrackingUrl = order.GetTrackingUrl();
}
//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.PluginDescriptor.FriendlyName : order.PaymentMethodSystemName;
//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);
model.Tax = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
foreach (var tr in order.TaxRatesDictionary)
{
model.TaxRates.Add(new OrderDetailsModel.TaxRate()
{
Rate = _priceFormatter.FormatTaxRate(tr.Key),
Value = _priceFormatter.FormatPrice(_currencyService.ConvertCurrency(tr.Value, order.CurrencyRate), true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false),
});
}
}
}
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 = Nop.Core.Html.HtmlHelper.FormatText(orderNote.Note, false, true, false, false, false, false),
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;
}
//picture
var picture = opv.ProductVariant.GetDefaultProductVariantPicture(_pictureService);
if (picture == null)
{
picture = _pictureService.GetPicturesByProductId(opv.ProductVariant.Product.Id, 1).FirstOrDefault();
}
var pictureModel = new PictureModel()
{
ImageUrl = _pictureService.GetPictureUrl(picture, _mediaSettings.CartThumbPictureSize, true),
Title = string.Format(_localizationService.GetResource("Media.Product.ImageLinkTitleFormat"), opv.ProductVariant.Product.Name),
AlternateText = string.Format(_localizationService.GetResource("Media.Product.ImageAlternateTextFormat"), opv.ProductVariant.Name),
};
opvModel.Picture = pictureModel;
}
//Order Items add Return Request
var returnRequests = _orderService.SearchReturnRequests(_workContext.CurrentCustomer.Id, 0, null);
model.HasReturnRequest = false;
foreach (var returnRequest in returnRequests)
{
var opv = _orderService.GetOrderProductVariantById(returnRequest.OrderProductVariantId);
if (opv.OrderId == model.Id)
{
model.HasReturnRequest = true;
var pv = opv.ProductVariant;
var request = new OrderDetailsModel.OrderProductVariantModel.OrderProductVariantReturnRequest()
{
RequestAction = returnRequest.RequestedAction,
ReturnRequestStatusId = returnRequest.ReturnRequestStatusId,
ReturnRequestStatus = returnRequest.ReturnRequestStatus.GetLocalizedEnum(_localizationService, _workContext),
ReturnRequestDate = returnRequest.UpdatedOnUtc
};
model.Items.Where(x => x.ProductId == pv.ProductId).FirstOrDefault().ItemsReturnRequest = request;
}
}
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 CheckoutShippingMethodModel PrepareShippingMethodModel(IList <ShoppingCartItem> cart)
{
var model = new CheckoutShippingMethodModel();
var shippingAddress = _addressService.GetAddressById(_workContext.CurrentCustomer.ShippingAddressId ?? 0);
var getShippingOptionResponse = _shippingService.GetShippingOptions(cart, shippingAddress);
if (getShippingOptionResponse.Success)
{
//performance optimization. cache returned shipping options.
//we'll use them later (after a customer has selected an option).
_genericAttributeService.SaveAttribute(_workContext.CurrentCustomer,
NopCustomerDefaults.OfferedShippingOptionsAttribute,
getShippingOptionResponse.ShippingOptions,
_storeContext.CurrentStore.Id);
foreach (var shippingOption in getShippingOptionResponse.ShippingOptions)
{
var soModel = new CheckoutShippingMethodModel.ShippingMethodModel
{
Name = shippingOption.Name,
Description = shippingOption.Description,
ShippingRateComputationMethodSystemName =
shippingOption.ShippingRateComputationMethodSystemName
};
//adjust rate
var shippingTotal = _orderTotalCalculationService.AdjustShippingRate(
shippingOption.Rate, cart, out _);
var rateBase = _taxService.GetShippingPrice(shippingTotal, _workContext.CurrentCustomer);
var rate =
_currencyService.ConvertFromPrimaryStoreCurrency(rateBase, _workContext.WorkingCurrency);
soModel.Fee = _priceFormatter.FormatShippingPrice(rate, true);
model.ShippingMethods.Add(soModel);
}
//find a selected (previously) shipping method
var selectedShippingOption = _genericAttributeService.GetAttribute <ShippingOption>(_workContext.CurrentCustomer, NopCustomerDefaults.SelectedShippingOptionAttribute, _storeContext.CurrentStore.Id);
CheckoutShippingMethodModel.ShippingMethodModel shippingOptionToSelect;
if (selectedShippingOption != null)
{
shippingOptionToSelect = model.ShippingMethods.ToList()
.Find(so => !string.IsNullOrEmpty(so.Name) && so.Name.Equals(selectedShippingOption.Name, StringComparison.InvariantCultureIgnoreCase) &&
!string.IsNullOrEmpty(so.ShippingRateComputationMethodSystemName) && so.ShippingRateComputationMethodSystemName.Equals(selectedShippingOption.ShippingRateComputationMethodSystemName, StringComparison.InvariantCultureIgnoreCase));
if (shippingOptionToSelect != null)
{
shippingOptionToSelect.Selected = true;
}
}
//if no option has been selected, let's do it for the first one
if (model.ShippingMethods.FirstOrDefault(so => so.Selected) != null)
{
return(model);
}
shippingOptionToSelect = model.ShippingMethods.FirstOrDefault();
if (shippingOptionToSelect != null)
{
shippingOptionToSelect.Selected = true;
}
}
else
{
foreach (var error in getShippingOptionResponse.Errors)
{
model.Warnings.Add(error);
}
}
return(model);
}
public async Task <LiquidOrder> Handle(GetOrderTokensCommand request, CancellationToken cancellationToken)
{
var language = await _languageService.GetLanguageById(request.Order.CustomerLanguageId);
var currency = await _currencyService.GetCurrencyByCode(request.Order.CustomerCurrencyCode);
var liquidOrder = new LiquidOrder(request.Order, request.Customer, language, currency, request.Store, request.OrderNote, request.Vendor);
foreach (var item in request.Order.OrderItems.Where(x => x.VendorId == request.Vendor?.Id || request.Vendor == null))
{
var product = await _productService.GetProductById(item.ProductId);
Vendor vendorItem = string.IsNullOrEmpty(item.VendorId) ? null : await _vendorService.GetVendorById(item.VendorId);
var liqitem = new LiquidOrderItem(item, product, request.Order, language, currency, request.Store, vendorItem);
#region Download
liqitem.IsDownloadAllowed = _downloadService.IsDownloadAllowed(request.Order, item, product);
liqitem.IsLicenseDownloadAllowed = _downloadService.IsLicenseDownloadAllowed(request.Order, item, product);
#endregion
#region Unit price
string unitPriceStr;
if (request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
unitPriceStr = _priceFormatter.FormatPrice(item.UnitPriceInclTax, true, currency, language, true);
}
else
{
//excluding tax
unitPriceStr = _priceFormatter.FormatPrice(item.UnitPriceExclTax, true, currency, language, false);
}
liqitem.UnitPrice = unitPriceStr;
#endregion
#region total price
string priceStr;
if (request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
priceStr = _priceFormatter.FormatPrice(item.PriceInclTax, true, currency, language, true);
}
else
{
//excluding tax
priceStr = _priceFormatter.FormatPrice(item.PriceExclTax, true, currency, language, false);
}
liqitem.TotalPrice = priceStr;
#endregion
string sku = "";
if (product != null)
{
sku = product.FormatSku(item.AttributesXml, _productAttributeParser);
}
liqitem.ProductSku = WebUtility.HtmlEncode(sku);
liqitem.ShowSkuOnProductDetailsPage = _catalogSettings.ShowSkuOnProductDetailsPage;
liqitem.ProductOldPrice = _priceFormatter.FormatPrice(product.OldPrice, true, currency, language, true);
liquidOrder.OrderItems.Add(liqitem);
}
liquidOrder.BillingCustomAttributes = await _addressAttributeFormatter.FormatAttributes(request.Order.BillingAddress?.CustomAttributes);
liquidOrder.BillingCountry = request.Order.BillingAddress != null && !string.IsNullOrEmpty(request.Order.BillingAddress.CountryId) ? (await _countryService.GetCountryById(request.Order.BillingAddress.CountryId))?.GetLocalized(x => x.Name, request.Order.CustomerLanguageId) : "";
liquidOrder.BillingStateProvince = !string.IsNullOrEmpty(request.Order.BillingAddress.StateProvinceId) ? (await _stateProvinceService.GetStateProvinceById(request.Order.BillingAddress.StateProvinceId))?.GetLocalized(x => x.Name, request.Order.CustomerLanguageId) : "";
liquidOrder.ShippingCountry = request.Order.ShippingAddress != null && !string.IsNullOrEmpty(request.Order.ShippingAddress.CountryId) ? (await _countryService.GetCountryById(request.Order.ShippingAddress.CountryId))?.GetLocalized(x => x.Name, request.Order.CustomerLanguageId) : "";
liquidOrder.ShippingStateProvince = request.Order.ShippingAddress != null && !string.IsNullOrEmpty(request.Order.ShippingAddress.StateProvinceId) ? (await _stateProvinceService.GetStateProvinceById(request.Order.ShippingAddress.StateProvinceId)).GetLocalized(x => x.Name, request.Order.CustomerLanguageId) : "";
liquidOrder.ShippingCustomAttributes = await _addressAttributeFormatter.FormatAttributes(request.Order.ShippingAddress != null?request.Order.ShippingAddress.CustomAttributes : "");
var paymentMethod = _paymentService.LoadPaymentMethodBySystemName(request.Order.PaymentMethodSystemName);
liquidOrder.PaymentMethod = paymentMethod != null?paymentMethod.GetLocalizedFriendlyName(_localizationService, language.Id) : request.Order.PaymentMethodSystemName;
liquidOrder.AmountRefunded = _priceFormatter.FormatPrice(request.RefundedAmount, true, currency, language, false);
Dictionary <string, string> dict = new Dictionary <string, string>();
foreach (var item in request.Order.OrderTaxes)
{
string taxRate = string.Format(_localizationService.GetResource("Messages.Order.TaxRateLine"), _priceFormatter.FormatTaxRate(item.Percent));
string taxValue = _priceFormatter.FormatPrice(item.Amount, true, currency, language, false);
dict.Add(taxRate, taxValue);
}
liquidOrder.TaxRates = dict;
Dictionary <string, string> cards = new Dictionary <string, string>();
var gcuhC = await _giftCardService.GetAllGiftCardUsageHistory(request.Order.Id);
foreach (var gcuh in gcuhC)
{
var giftCard = await _giftCardService.GetGiftCardById(gcuh.GiftCardId);
string giftCardText = string.Format(_localizationService.GetResource("Messages.Order.GiftCardInfo", language.Id), WebUtility.HtmlEncode(giftCard.GiftCardCouponCode));
string giftCardAmount = _priceFormatter.FormatPrice(-gcuh.UsedValue, true, currency, language, false);
cards.Add(giftCardText, giftCardAmount);
}
liquidOrder.GiftCards = cards;
if (request.Order.RedeemedRewardPointsEntry != null)
{
liquidOrder.RPTitle = string.Format(_localizationService.GetResource("Messages.Order.RewardPoints", language.Id), -request.Order.RedeemedRewardPointsEntry?.Points);
liquidOrder.RPAmount = _priceFormatter.FormatPrice(-request.Order.RedeemedRewardPointsEntry.UsedAmount, true, currency, language, false);
}
void CalculateSubTotals()
{
string _cusSubTotal;
bool _displaySubTotalDiscount;
string _cusSubTotalDiscount;
string _cusShipTotal;
string _cusPaymentMethodAdditionalFee;
bool _displayTax;
string _cusTaxTotal;
bool _displayTaxRates;
bool _displayDiscount;
string _cusDiscount;
string _cusTotal;
_displaySubTotalDiscount = false;
_cusSubTotalDiscount = string.Empty;
if (request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal)
{
//including tax
//subtotal
_cusSubTotal = _priceFormatter.FormatPrice(request.Order.OrderSubtotalInclTax, true, currency, language, true);
//discount (applied to order subtotal)
if (request.Order.OrderSubTotalDiscountInclTax > decimal.Zero)
{
_cusSubTotalDiscount = _priceFormatter.FormatPrice(-request.Order.OrderSubTotalDiscountInclTax, true, currency, language, true);
_displaySubTotalDiscount = true;
}
}
else
{
//exсluding tax
//subtotal
_cusSubTotal = _priceFormatter.FormatPrice(request.Order.OrderSubtotalExclTax, true, currency, language, false);
//discount (applied to order subtotal)
if (request.Order.OrderSubTotalDiscountExclTax > decimal.Zero)
{
_cusSubTotalDiscount = _priceFormatter.FormatPrice(-request.Order.OrderSubTotalDiscountExclTax, true, currency, language, false);
_displaySubTotalDiscount = true;
}
}
//shipping, payment method fee
_cusTaxTotal = string.Empty;
_cusDiscount = string.Empty;
if (request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
//shipping
_cusShipTotal = _priceFormatter.FormatShippingPrice(request.Order.OrderShippingInclTax, true, currency, language, true);
//payment method additional fee
_cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(request.Order.PaymentMethodAdditionalFeeInclTax, true, currency, language, true);
}
else
{
//excluding tax
//shipping
_cusShipTotal = _priceFormatter.FormatShippingPrice(request.Order.OrderShippingExclTax, true, currency, language, false);
//payment method additional fee
_cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(request.Order.PaymentMethodAdditionalFeeExclTax, true, currency, language, false);
}
//shipping
bool displayShipping = request.Order.ShippingStatus != ShippingStatus.ShippingNotRequired;
//payment method fee
bool displayPaymentMethodFee = request.Order.PaymentMethodAdditionalFeeExclTax > decimal.Zero;
//tax
_displayTax = true;
_displayTaxRates = true;
if (_taxSettings.HideTaxInOrderSummary && request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
_displayTax = false;
_displayTaxRates = false;
}
else
{
if (request.Order.OrderTax == 0 && _taxSettings.HideZeroTax)
{
_displayTax = false;
_displayTaxRates = false;
}
else
{
_displayTaxRates = _taxSettings.DisplayTaxRates && request.Order.OrderTaxes.Any();
_displayTax = !_displayTaxRates;
string taxStr = _priceFormatter.FormatPrice(request.Order.OrderTax, true, currency, language, request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
_cusTaxTotal = taxStr;
}
}
//discount
_displayDiscount = false;
if (request.Order.OrderDiscount > decimal.Zero)
{
_cusDiscount = _priceFormatter.FormatPrice(-request.Order.OrderDiscount, true, currency, language, request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
_displayDiscount = true;
}
//total
_cusTotal = _priceFormatter.FormatPrice(request.Order.OrderTotal, true, currency, language, request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
liquidOrder.SubTotal = _cusSubTotal;
liquidOrder.DisplaySubTotalDiscount = _displaySubTotalDiscount;
liquidOrder.SubTotalDiscount = _cusSubTotalDiscount;
liquidOrder.Shipping = _cusShipTotal;
liquidOrder.Discount = _cusDiscount;
liquidOrder.PaymentMethodAdditionalFee = _cusPaymentMethodAdditionalFee;
liquidOrder.Tax = _cusTaxTotal;
liquidOrder.Total = _cusTotal;
liquidOrder.DisplayTax = _displayTax;
liquidOrder.DisplayDiscount = _displayDiscount;
liquidOrder.DisplayTaxRates = _displayTaxRates;
}
CalculateSubTotals();
return(liquidOrder);
}
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 CheckoutShippingMethodModel PrepareShippingMethodModel(IList <OrganizedShoppingCartItem> cart)
{
var model = new CheckoutShippingMethodModel();
var getShippingOptionResponse = _shippingService.GetShippingOptions(cart, _workContext.CurrentCustomer.ShippingAddress, "", _storeContext.CurrentStore.Id);
if (getShippingOptionResponse.Success)
{
//performance optimization. cache returned shipping options.
//we'll use them later (after a customer has selected an option).
_genericAttributeService.SaveAttribute(_workContext.CurrentCustomer,
SystemCustomerAttributeNames.OfferedShippingOptions, getShippingOptionResponse.ShippingOptions, _storeContext.CurrentStore.Id);
var shippingMethods = _shippingService.GetAllShippingMethods();
foreach (var shippingOption in getShippingOptionResponse.ShippingOptions)
{
var soModel = new CheckoutShippingMethodModel.ShippingMethodModel()
{
ShippingMethodId = shippingOption.ShippingMethodId,
Name = shippingOption.Name,
Description = shippingOption.Description,
ShippingRateComputationMethodSystemName = shippingOption.ShippingRateComputationMethodSystemName,
};
var srcmProvider = _shippingService.LoadShippingRateComputationMethodBySystemName(shippingOption.ShippingRateComputationMethodSystemName);
if (srcmProvider != null)
{
soModel.BrandUrl = _pluginMediator.GetBrandImageUrl(srcmProvider.Metadata);
}
//adjust rate
Discount appliedDiscount = null;
var shippingTotal = _orderTotalCalculationService.AdjustShippingRate(
shippingOption.Rate, cart, shippingOption.Name, shippingMethods, out appliedDiscount);
decimal rateBase = _taxService.GetShippingPrice(shippingTotal, _workContext.CurrentCustomer);
decimal rate = _currencyService.ConvertFromPrimaryStoreCurrency(rateBase, _workContext.WorkingCurrency);
soModel.FeeRaw = rate;
soModel.Fee = _priceFormatter.FormatShippingPrice(rate, true);
model.ShippingMethods.Add(soModel);
}
//find a selected (previously) shipping method
var selectedShippingOption = _workContext.CurrentCustomer.GetAttribute <ShippingOption>(SystemCustomerAttributeNames.SelectedShippingOption, _storeContext.CurrentStore.Id);
if (selectedShippingOption != null)
{
var shippingOptionToSelect = model.ShippingMethods.ToList()
.Find(so => !String.IsNullOrEmpty(so.Name) && so.Name.Equals(selectedShippingOption.Name, StringComparison.InvariantCultureIgnoreCase) &&
!String.IsNullOrEmpty(so.ShippingRateComputationMethodSystemName) &&
so.ShippingRateComputationMethodSystemName.Equals(selectedShippingOption.ShippingRateComputationMethodSystemName, StringComparison.InvariantCultureIgnoreCase));
if (shippingOptionToSelect != null)
{
shippingOptionToSelect.Selected = true;
}
}
//if no option has been selected, let's do it for the first one
if (model.ShippingMethods.Where(so => so.Selected).FirstOrDefault() == null)
{
var shippingOptionToSelect = model.ShippingMethods.FirstOrDefault();
if (shippingOptionToSelect != null)
{
shippingOptionToSelect.Selected = true;
}
}
}
else
{
foreach (var error in getShippingOptionResponse.Errors)
{
model.Warnings.Add(error);
}
}
return(model);
}
public async Task <EstimateShippingResultModel> Handle(GetEstimateShippingResult request, CancellationToken cancellationToken)
{
var model = new EstimateShippingResultModel();
if (request.Cart.RequiresShipping())
{
var address = new Address {
CountryId = request.CountryId,
StateProvinceId = request.StateProvinceId,
ZipPostalCode = request.ZipPostalCode,
};
GetShippingOptionResponse getShippingOptionResponse = await _shippingService
.GetShippingOptions(request.Customer, request.Cart, address, "", request.Store);
if (!getShippingOptionResponse.Success)
{
foreach (var error in getShippingOptionResponse.Errors)
{
model.Warnings.Add(error);
}
}
else
{
if (getShippingOptionResponse.ShippingOptions.Any())
{
foreach (var shippingOption in getShippingOptionResponse.ShippingOptions)
{
var soModel = new EstimateShippingResultModel.ShippingOptionModel {
Name = shippingOption.Name,
Description = shippingOption.Description,
};
//calculate discounted and taxed rate
var total = await _orderTotalCalculationService.AdjustShippingRate(shippingOption.Rate, request.Cart);
List <AppliedDiscount> appliedDiscounts = total.appliedDiscounts;
decimal shippingTotal = total.shippingRate;
decimal rateBase = (await _taxService.GetShippingPrice(shippingTotal, request.Customer)).shippingPrice;
decimal rate = await _currencyService.ConvertFromPrimaryStoreCurrency(rateBase, request.Currency);
soModel.Price = _priceFormatter.FormatShippingPrice(rate, true);
model.ShippingOptions.Add(soModel);
}
//pickup in store?
if (_shippingSettings.AllowPickUpInStore)
{
var pickupPoints = await _shippingService.GetAllPickupPoints();
if (pickupPoints.Count > 0)
{
var soModel = new EstimateShippingResultModel.ShippingOptionModel {
Name = _localizationService.GetResource("Checkout.PickUpInStore"),
Description = _localizationService.GetResource("Checkout.PickUpInStore.Description"),
};
decimal shippingTotal = pickupPoints.Max(x => x.PickupFee);
decimal rateBase = (await _taxService.GetShippingPrice(shippingTotal, request.Customer)).shippingPrice;
decimal rate = await _currencyService.ConvertFromPrimaryStoreCurrency(rateBase, request.Currency);
soModel.Price = _priceFormatter.FormatShippingPrice(rate, true);
model.ShippingOptions.Add(soModel);
}
}
}
else
{
model.Warnings.Add(_localizationService.GetResource("Checkout.ShippingIsNotAllowed"));
}
}
}
return(model);
}