/// <summary>
/// Prepare billing address model
/// </summary>
/// <param name="cart">Cart</param>
/// <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>
/// A task that represents the asynchronous operation
/// The task result contains the billing address model
/// </returns>
public virtual async Task <CheckoutBillingAddressModel> PrepareBillingAddressModelAsync(IList <ShoppingCartItem> cart,
int?selectedCountryId = null,
bool prePopulateNewAddressWithCustomerFields = false,
string overrideAttributesXml = "")
{
var model = new CheckoutBillingAddressModel
{
ShipToSameAddressAllowed = _shippingSettings.ShipToSameAddress && await _shoppingCartService.ShoppingCartRequiresShippingAsync(cart),
//allow customers to enter (choose) a shipping address if "Disable Billing address step" setting is enabled
ShipToSameAddress = !_orderSettings.DisableBillingAddressCheckoutStep
};
//existing addresses
var customer = await _workContext.GetCurrentCustomerAsync();
var addresses = await(await _customerService.GetAddressesByCustomerIdAsync(customer.Id))
.WhereAwait(async a => !a.CountryId.HasValue || await _countryService.GetCountryByAddressAsync(a) is Country country &&
(//published
country.Published &&
//allow billing
country.AllowsBilling &&
//enabled for the current store
await _storeMappingService.AuthorizeAsync(country)))
.ToListAsync();
foreach (var address in addresses)
{
var addressModel = new AddressModel();
await _addressModelFactory.PrepareAddressModelAsync(addressModel,
address : address,
excludeProperties : false,
addressSettings : _addressSettings);
if (await _addressService.IsAddressValidAsync(address))
{
model.ExistingAddresses.Add(addressModel);
}
else
{
model.InvalidExistingAddresses.Add(addressModel);
}
}
//new address
model.BillingNewAddress.CountryId = selectedCountryId;
await _addressModelFactory.PrepareAddressModelAsync(model.BillingNewAddress,
address : null,
excludeProperties : false,
addressSettings : _addressSettings,
loadCountries : async() => await _countryService.GetAllCountriesForBillingAsync((await _workContext.GetWorkingLanguageAsync()).Id),
prePopulateWithCustomerFields : prePopulateNewAddressWithCustomerFields,
customer : customer,
overrideAttributesXml : overrideAttributesXml);
return(model);
}
/// <summary>
/// Prepare warehouse model
/// </summary>
/// <param name="model">Warehouse model</param>
/// <param name="warehouse">Warehouse</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the warehouse model
/// </returns>
public virtual async Task <WarehouseModel> PrepareWarehouseModelAsync(WarehouseModel model, Warehouse warehouse, bool excludeProperties = false)
{
if (warehouse != null)
{
//fill in model values from the entity
if (model == null)
{
model = warehouse.ToModel <WarehouseModel>();
}
}
//prepare address model
var address = await _addressService.GetAddressByIdAsync(warehouse?.AddressId ?? 0);
if (!excludeProperties && address != null)
{
model.Address = address.ToModel(model.Address);
}
await _addressModelFactory.PrepareAddressModelAsync(model.Address, address);
model.Address.CountryRequired = true;
model.Address.ZipPostalCodeRequired = true;
return(model);
}
/// <summary>
/// Prepare affiliate model
/// </summary>
/// <param name="model">Affiliate model</param>
/// <param name="affiliate">Affiliate</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the affiliate model
/// </returns>
public virtual async Task <AffiliateModel> PrepareAffiliateModelAsync(AffiliateModel model, Affiliate affiliate, bool excludeProperties = false)
{
//fill in model values from the entity
if (affiliate != null)
{
model ??= affiliate.ToModel <AffiliateModel>();
model.Url = await _affiliateService.GenerateUrlAsync(affiliate);
//prepare nested search models
await PrepareAffiliatedOrderSearchModelAsync(model.AffiliatedOrderSearchModel, affiliate);
PrepareAffiliatedCustomerSearchModel(model.AffiliatedCustomerSearchModel, affiliate);
//whether to fill in some of properties
if (!excludeProperties)
{
model.AdminComment = affiliate.AdminComment;
model.FriendlyUrlName = affiliate.FriendlyUrlName;
model.Active = affiliate.Active;
}
}
//prepare address model
var address = await _addressService.GetAddressByIdAsync(affiliate?.AddressId ?? 0);
if (!excludeProperties && address != null)
{
model.Address = address.ToModel(model.Address);
}
await _addressModelFactory.PrepareAddressModelAsync(model.Address, address);
model.Address.FirstNameRequired = true;
model.Address.LastNameRequired = true;
model.Address.EmailRequired = true;
model.Address.CountryRequired = true;
model.Address.CountyRequired = true;
model.Address.CityRequired = true;
model.Address.StreetAddressRequired = true;
model.Address.ZipPostalCodeRequired = true;
model.Address.PhoneRequired = true;
return(model);
}
public virtual async Task <CustomerAddressModel> PrepareCompanyCustomerAddressModelAsync(CustomerAddressModel model,
Company company, Address address, bool excludeProperties = false)
{
if (company == null)
{
throw new ArgumentNullException(nameof(company));
}
if (address != null)
{
//fill in model values from the entity
model ??= new CustomerAddressModel();
//whether to fill in some of properties
if (!excludeProperties)
{
model.Address = address.ToModel(model.Address);
}
}
model.CustomerId = company.Id;
//prepare address model
await _addressModelFactory.PrepareAddressModelAsync(model.Address, address);
model.Address.FirstNameRequired = true;
model.Address.LastNameRequired = true;
model.Address.EmailRequired = true;
model.Address.CompanyRequired = _addressSettings.CompanyRequired;
model.Address.CityRequired = _addressSettings.CityRequired;
model.Address.CountyRequired = _addressSettings.CountyRequired;
model.Address.StreetAddressRequired = _addressSettings.StreetAddressRequired;
model.Address.StreetAddress2Required = _addressSettings.StreetAddress2Required;
model.Address.ZipPostalCodeRequired = _addressSettings.ZipPostalCodeRequired;
model.Address.PhoneRequired = _addressSettings.PhoneRequired;
model.Address.FaxRequired = _addressSettings.FaxRequired;
return(model);
}
public async Task PrepareAddressModelShouldPopulatingPropertiesFromEntity()
{
var model = new AddressModel();
await _addressModelFactory.PrepareAddressModelAsync(model, _address, false, _addressSettings);
model.Id.Should().Be(_address.Id);
model.FirstName.Should().Be(_address.FirstName);
model.LastName.Should().Be(_address.LastName);
model.Email.Should().Be(_address.Email);
model.Company.Should().Be(_address.Company);
model.CountryId.Should().Be(_address.CountryId);
model.StateProvinceId.Should().Be(_address.StateProvinceId);
model.County.Should().Be(_address.County);
model.City.Should().Be(_address.City);
model.Address1.Should().Be(_address.Address1);
model.Address2.Should().Be(_address.Address2);
model.ZipPostalCode.Should().Be(_address.ZipPostalCode);
model.PhoneNumber.Should().Be(_address.PhoneNumber);
model.FaxNumber.Should().Be(_address.FaxNumber);
}
/// <summary>
/// Prepare vendor model
/// </summary>
/// <param name="model">Vendor model</param>
/// <param name="vendor">Vendor</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the vendor model
/// </returns>
public virtual async Task <VendorModel> PrepareVendorModelAsync(VendorModel model, Vendor vendor, bool excludeProperties = false)
{
Action <VendorLocalizedModel, int> localizedModelConfiguration = null;
if (vendor != null)
{
//fill in model values from the entity
if (model == null)
{
model = vendor.ToModel <VendorModel>();
model.SeName = await _urlRecordService.GetSeNameAsync(vendor, 0, true, false);
}
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(vendor, entity => entity.Name, languageId, false, false);
locale.Description = await _localizationService.GetLocalizedAsync(vendor, entity => entity.Description, languageId, false, false);
locale.MetaKeywords = await _localizationService.GetLocalizedAsync(vendor, entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = await _localizationService.GetLocalizedAsync(vendor, entity => entity.MetaDescription, languageId, false, false);
locale.MetaTitle = await _localizationService.GetLocalizedAsync(vendor, entity => entity.MetaTitle, languageId, false, false);
locale.SeName = await _urlRecordService.GetSeNameAsync(vendor, languageId, false, false);
};
//prepare associated customers
await PrepareAssociatedCustomerModelsAsync(model.AssociatedCustomers, vendor);
//prepare nested search models
PrepareVendorNoteSearchModel(model.VendorNoteSearchModel, vendor);
}
//set default values for the new model
if (vendor == null)
{
model.PageSize = 6;
model.Active = true;
model.AllowCustomersToSelectPageSize = true;
model.PageSizeOptions = _vendorSettings.DefaultVendorPageSizeOptions;
model.PriceRangeFiltering = true;
model.ManuallyPriceRange = true;
model.PriceFrom = NopCatalogDefaults.DefaultPriceRangeFrom;
model.PriceTo = NopCatalogDefaults.DefaultPriceRangeTo;
}
model.PrimaryStoreCurrencyCode = (await _currencyService.GetCurrencyByIdAsync(_currencySettings.PrimaryStoreCurrencyId)).CurrencyCode;
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
//prepare model vendor attributes
await PrepareVendorAttributeModelsAsync(model.VendorAttributes, vendor);
//prepare address model
var address = await _addressService.GetAddressByIdAsync(vendor?.AddressId ?? 0);
if (!excludeProperties && address != null)
{
model.Address = address.ToModel(model.Address);
}
await _addressModelFactory.PrepareAddressModelAsync(model.Address, address);
return(model);
}
/// <summary>
/// Prepare the order details model
/// </summary>
/// <param name="order">Order</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the order details model
/// </returns>
public virtual async Task <OrderDetailsModel> PrepareOrderDetailsModelAsync(Order order)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
var model = new OrderDetailsModel
{
Id = order.Id,
CreatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(order.CreatedOnUtc, DateTimeKind.Utc),
OrderStatus = await _localizationService.GetLocalizedEnumAsync(order.OrderStatus),
IsReOrderAllowed = _orderSettings.IsReOrderAllowed,
IsReturnRequestAllowed = await _orderProcessingService.IsReturnRequestAllowedAsync(order),
PdfInvoiceDisabled = _pdfSettings.DisablePdfInvoicesForPendingOrders && order.OrderStatus == OrderStatus.Pending,
CustomOrderNumber = order.CustomOrderNumber,
//shipping info
ShippingStatus = await _localizationService.GetLocalizedEnumAsync(order.ShippingStatus)
};
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.PickupInStore = order.PickupInStore;
if (!order.PickupInStore)
{
var shippingAddress = await _addressService.GetAddressByIdAsync(order.ShippingAddressId ?? 0);
await _addressModelFactory.PrepareAddressModelAsync(model.ShippingAddress,
address : shippingAddress,
excludeProperties : false,
addressSettings : _addressSettings);
}
else if (order.PickupAddressId.HasValue && await _addressService.GetAddressByIdAsync(order.PickupAddressId.Value) is Address pickupAddress)
{
model.PickupAddress = new AddressModel
{
Address1 = pickupAddress.Address1,
City = pickupAddress.City,
County = pickupAddress.County,
StateProvinceName = await _stateProvinceService.GetStateProvinceByAddressAsync(pickupAddress) is StateProvince stateProvince
? await _localizationService.GetLocalizedAsync(stateProvince, entity => entity.Name)
: string.Empty,
CountryName = await _countryService.GetCountryByAddressAsync(pickupAddress) is Country country
? await _localizationService.GetLocalizedAsync(country, entity => entity.Name)
: string.Empty,
ZipPostalCode = pickupAddress.ZipPostalCode
};
}
model.ShippingMethod = order.ShippingMethod;
//shipments (only already shipped or ready for pickup)
var shipments = (await _shipmentService.GetShipmentsByOrderIdAsync(order.Id, !order.PickupInStore, order.PickupInStore)).OrderBy(x => x.CreatedOnUtc).ToList();
foreach (var shipment in shipments)
{
var shipmentModel = new OrderDetailsModel.ShipmentBriefModel
{
Id = shipment.Id,
TrackingNumber = shipment.TrackingNumber,
};
if (shipment.ShippedDateUtc.HasValue)
{
shipmentModel.ShippedDate = await _dateTimeHelper.ConvertToUserTimeAsync(shipment.ShippedDateUtc.Value, DateTimeKind.Utc);
}
if (shipment.ReadyForPickupDateUtc.HasValue)
{
shipmentModel.ReadyForPickupDate = await _dateTimeHelper.ConvertToUserTimeAsync(shipment.ReadyForPickupDateUtc.Value, DateTimeKind.Utc);
}
if (shipment.DeliveryDateUtc.HasValue)
{
shipmentModel.DeliveryDate = await _dateTimeHelper.ConvertToUserTimeAsync(shipment.DeliveryDateUtc.Value, DateTimeKind.Utc);
}
model.Shipments.Add(shipmentModel);
}
}
var billingAddress = await _addressService.GetAddressByIdAsync(order.BillingAddressId);
//billing info
await _addressModelFactory.PrepareAddressModelAsync(model.BillingAddress,
address : billingAddress,
excludeProperties : false,
addressSettings : _addressSettings);
//VAT number
model.VatNumber = order.VatNumber;
var languageId = (await _workContext.GetWorkingLanguageAsync()).Id;
//payment method
var customer = await _customerService.GetCustomerByIdAsync(order.CustomerId);
var paymentMethod = await _paymentPluginManager
.LoadPluginBySystemNameAsync(order.PaymentMethodSystemName, customer, order.StoreId);
model.PaymentMethod = paymentMethod != null ? await _localizationService.GetLocalizedFriendlyNameAsync(paymentMethod, languageId) : order.PaymentMethodSystemName;
model.PaymentMethodStatus = await _localizationService.GetLocalizedEnumAsync(order.PaymentStatus);
model.CanRePostProcessPayment = await _paymentService.CanRePostProcessPaymentAsync(order);
//custom values
model.CustomValues = _paymentService.DeserializeCustomValues(order);
//order subtotal
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal)
{
//including tax
//order subtotal
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
model.OrderSubtotal = await _priceFormatter.FormatPriceAsync(orderSubtotalInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
model.OrderSubtotalValue = orderSubtotalInclTaxInCustomerCurrency;
//discount (applied to order subtotal)
var orderSubTotalDiscountInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountInclTax, order.CurrencyRate);
if (orderSubTotalDiscountInclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = await _priceFormatter.FormatPriceAsync(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
model.OrderSubTotalDiscountValue = orderSubTotalDiscountInclTaxInCustomerCurrency;
}
}
else
{
//excluding tax
//order subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = await _priceFormatter.FormatPriceAsync(orderSubtotalExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
model.OrderSubtotalValue = orderSubtotalExclTaxInCustomerCurrency;
//discount (applied to order subtotal)
var orderSubTotalDiscountExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountExclTax, order.CurrencyRate);
if (orderSubTotalDiscountExclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = await _priceFormatter.FormatPriceAsync(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
model.OrderSubTotalDiscountValue = orderSubTotalDiscountExclTaxInCustomerCurrency;
}
}
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
//order shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
model.OrderShipping = await _priceFormatter.FormatShippingPriceAsync(orderShippingInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
model.OrderShippingValue = orderShippingInclTaxInCustomerCurrency;
//payment method additional fee
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeInclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = await _priceFormatter.FormatPaymentMethodAdditionalFeeAsync(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
model.PaymentMethodAdditionalFeeValue = paymentMethodAdditionalFeeInclTaxInCustomerCurrency;
}
}
else
{
//excluding tax
//order shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = await _priceFormatter.FormatShippingPriceAsync(orderShippingExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
model.OrderShippingValue = orderShippingExclTaxInCustomerCurrency;
//payment method additional fee
var paymentMethodAdditionalFeeExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeExclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = await _priceFormatter.FormatPaymentMethodAdditionalFeeAsync(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
model.PaymentMethodAdditionalFeeValue = paymentMethodAdditionalFeeExclTaxInCustomerCurrency;
}
}
//tax
var displayTax = true;
var displayTaxRates = true;
if (_taxSettings.HideTaxInOrderSummary && order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
if (order.OrderTax == 0 && _taxSettings.HideZeroTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
var taxRates = _orderService.ParseTaxRates(order, order.TaxRates);
displayTaxRates = _taxSettings.DisplayTaxRates && taxRates.Any();
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
model.Tax = await _priceFormatter.FormatPriceAsync(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
foreach (var tr in taxRates)
{
model.TaxRates.Add(new OrderDetailsModel.TaxRate
{
Rate = _priceFormatter.FormatTaxRate(tr.Key),
Value = await _priceFormatter.FormatPriceAsync(_currencyService.ConvertCurrency(tr.Value, order.CurrencyRate), true, order.CustomerCurrencyCode, false, languageId),
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
model.DisplayTaxShippingInfo = _catalogSettings.DisplayTaxShippingInfoOrderDetailsPage;
model.PricesIncludeTax = order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax;
//discount (applied to order total)
var orderDiscountInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderDiscount, order.CurrencyRate);
if (orderDiscountInCustomerCurrency > decimal.Zero)
{
model.OrderTotalDiscount = await _priceFormatter.FormatPriceAsync(-orderDiscountInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
model.OrderTotalDiscountValue = orderDiscountInCustomerCurrency;
}
//gift cards
foreach (var gcuh in await _giftCardService.GetGiftCardUsageHistoryAsync(order))
{
model.GiftCards.Add(new OrderDetailsModel.GiftCard
{
CouponCode = (await _giftCardService.GetGiftCardByIdAsync(gcuh.GiftCardId)).GiftCardCouponCode,
Amount = await _priceFormatter.FormatPriceAsync(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, languageId),
});
}
//reward points
if (order.RedeemedRewardPointsEntryId.HasValue && await _rewardPointService.GetRewardPointsHistoryEntryByIdAsync(order.RedeemedRewardPointsEntryId.Value) is RewardPointsHistory redeemedRewardPointsEntry)
{
model.RedeemedRewardPoints = -redeemedRewardPointsEntry.Points;
model.RedeemedRewardPointsAmount = await _priceFormatter.FormatPriceAsync(-(_currencyService.ConvertCurrency(redeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, languageId);
}
//total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
model.OrderTotal = await _priceFormatter.FormatPriceAsync(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, languageId);
model.OrderTotalValue = orderTotalInCustomerCurrency;
//checkout attributes
model.CheckoutAttributeInfo = order.CheckoutAttributeDescription;
//order notes
foreach (var orderNote in (await _orderService.GetOrderNotesByOrderIdAsync(order.Id, true))
.OrderByDescending(on => on.CreatedOnUtc)
.ToList())
{
model.OrderNotes.Add(new OrderDetailsModel.OrderNote
{
Id = orderNote.Id,
HasDownload = orderNote.DownloadId > 0,
Note = _orderService.FormatOrderNoteText(orderNote),
CreatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(orderNote.CreatedOnUtc, DateTimeKind.Utc)
});
}
//purchased products
model.ShowSku = _catalogSettings.ShowSkuOnProductDetailsPage;
model.ShowVendorName = _vendorSettings.ShowVendorOnOrderDetailsPage;
var orderItems = await _orderService.GetOrderItemsAsync(order.Id);
foreach (var orderItem in orderItems)
{
var product = await _productService.GetProductByIdAsync(orderItem.ProductId);
var orderItemModel = new OrderDetailsModel.OrderItemModel
{
Id = orderItem.Id,
OrderItemGuid = orderItem.OrderItemGuid,
Sku = await _productService.FormatSkuAsync(product, orderItem.AttributesXml),
VendorName = (await _vendorService.GetVendorByIdAsync(product.VendorId))?.Name ?? string.Empty,
ProductId = product.Id,
ProductName = await _localizationService.GetLocalizedAsync(product, x => x.Name),
ProductSeName = await _urlRecordService.GetSeNameAsync(product),
Quantity = orderItem.Quantity,
AttributeInfo = orderItem.AttributeDescription,
};
//rental info
if (product.IsRental)
{
var rentalStartDate = orderItem.RentalStartDateUtc.HasValue
? _productService.FormatRentalDate(product, orderItem.RentalStartDateUtc.Value) : "";
var rentalEndDate = orderItem.RentalEndDateUtc.HasValue
? _productService.FormatRentalDate(product, orderItem.RentalEndDateUtc.Value) : "";
orderItemModel.RentalInfo = string.Format(await _localizationService.GetResourceAsync("Order.Rental.FormattedDate"),
rentalStartDate, rentalEndDate);
}
model.Items.Add(orderItemModel);
//unit price, subtotal
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = await _priceFormatter.FormatPriceAsync(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
orderItemModel.UnitPriceValue = unitPriceInclTaxInCustomerCurrency;
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
orderItemModel.SubTotal = await _priceFormatter.FormatPriceAsync(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, true);
orderItemModel.SubTotalValue = priceInclTaxInCustomerCurrency;
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = await _priceFormatter.FormatPriceAsync(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
orderItemModel.UnitPriceValue = unitPriceExclTaxInCustomerCurrency;
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
orderItemModel.SubTotal = await _priceFormatter.FormatPriceAsync(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, languageId, false);
orderItemModel.SubTotalValue = priceExclTaxInCustomerCurrency;
}
//downloadable products
if (await _orderService.IsDownloadAllowedAsync(orderItem))
{
orderItemModel.DownloadId = product.DownloadId;
}
if (await _orderService.IsLicenseDownloadAllowedAsync(orderItem))
{
orderItemModel.LicenseId = orderItem.LicenseDownloadId ?? 0;
}
}
return(model);
}
/// <summary>
/// Prepare pickup model
/// </summary>
/// <param name="model">Pickup model</param>
/// <param name="shipment">Shipment; pass null if it's a pickup for the batch</param>
/// <param name="batch">Batch; pass null if it's a pickup for the shipment</param>
/// <param name="addressId">Address id</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the pickup model
/// </returns>
public async Task <PickupModel> PreparePickupModelAsync(PickupModel model, Shipment shipment, EasyPostBatch batch, int?addressId)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var pickupId = shipment is not null
? await _genericAttributeService.GetAttributeAsync <string>(shipment, EasyPostDefaults.PickupIdAttribute)
: batch?.PickupId;
model.PickupId = pickupId;
model.ShipmentId = shipment?.Id;
model.BatchId = batch?.Id;
if (!string.IsNullOrEmpty(pickupId))
{
var(pickup, _) = await _easyPostService.GetPickupAsync(pickupId);
model.Created = pickup is not null;
model.Status = pickup?.status ?? "not found";
model.Purchased = string.Equals(pickup?.status, "scheduled", StringComparison.InvariantCultureIgnoreCase);
if (model.Created && !model.Purchased)
{
var(pickupRates, _) = await _easyPostService.GetPickupRatesAsync(pickup);
if (pickupRates?.Any() ?? false)
{
model.AvailablePickupRates = await pickupRates.OrderBy(rate => rate.Rate).SelectAwait(async rate =>
{
var rateName = $"{rate.Carrier} {rate.Service}".TrimEnd(' ');
var text = $"{await _priceFormatter.FormatShippingPriceAsync(rate.Rate, true)} {rateName}";
return(new SelectListItem(text, rate.Id));
}).ToListAsync();
}
else
{
var locale = await _localizationService.GetResourceAsync("Plugins.Shipping.EasyPost.Pickup.Rate.None");
model.AvailablePickupRates.Add(new SelectListItem(locale, string.Empty));
}
}
}
if (!model.Created)
{
var address = await _addressService.GetAddressByIdAsync(addressId ?? 0);
if (address is not null)
{
model.PickupAddress = address.ToModel(model.PickupAddress);
}
await _addressModelFactory.PrepareAddressModelAsync(model.PickupAddress, address);
model.PickupAddress.CustomAddressAttributes.Clear();
model.MinDate = DateTime.UtcNow.AddDays(1).Date;
model.MaxDate = DateTime.UtcNow.AddDays(7).Date;
}
return(model);
}