Open-source eCommerce platform for C# and ASP.NET Core 10 with MongoDB. Build multi-store shops and multi-vendor marketplaces with B2B/B2C, REST API, plugins, Vue 3 and Docker.
C# aspnet-corecsharpdockerdotnetecommerceecommerce-platformmongodbmulti-storemulti-vendornosqlonline-shopshoppingcart
using Grand.Business.Core.Commands.Checkout.Orders;
using Grand.Business.Core.Extensions;
using Grand.Business.Core.Interfaces.Catalog.Discounts;
using Grand.Business.Core.Interfaces.Catalog.Prices;
using Grand.Business.Core.Interfaces.Catalog.Products;
using Grand.Business.Core.Interfaces.Catalog.Tax;
using Grand.Business.Core.Interfaces.Checkout.GiftVouchers;
using Grand.Business.Core.Interfaces.Checkout.Orders;
using Grand.Business.Core.Interfaces.Checkout.Payments;
using Grand.Business.Core.Interfaces.Checkout.Shipping;
using Grand.Business.Core.Interfaces.Common.Addresses;
using Grand.Business.Core.Interfaces.Common.Directory;
using Grand.Business.Core.Interfaces.Common.Localization;
using Grand.Business.Core.Interfaces.Common.Stores;
using Grand.Business.Core.Interfaces.Customers;
using Grand.Business.Core.Interfaces.Messages;
using Grand.Business.Core.Interfaces.Storage;
using Grand.Business.Core.Queries.Catalog;
using Grand.Domain.Catalog;
using Grand.Domain.Common;
using Grand.Domain.Directory;
using Grand.Domain.Media;
using Grand.Domain.Orders;
using Grand.Domain.Payments;
using Grand.Domain.Shipping;
using Grand.Domain.Tax;
using Grand.Infrastructure;
using Grand.Web.AdminShared.Extensions.Mapping;
using Grand.Web.AdminShared.Interfaces;
using Grand.Web.AdminShared.Models.Orders;
using Grand.Web.Common.Localization;
using Grand.Mediator;
using Microsoft.AspNetCore.Mvc.Rendering;
using System.Net;
using ProductExtensions = Grand.Domain.Catalog.ProductExtensions;
using Grand.Business.Core.Queries.Checkout.Orders;
namespace Grand.Web.AdminShared.Services;
public class OrderViewModelService : IOrderViewModelService
{
#region Fields
private readonly IOrderService _orderService;
private readonly IPricingService _pricingService;
private readonly IDateTimeService _dateTimeService;
private readonly IPriceFormatter _priceFormatter;
private readonly IDiscountService _discountService;
private readonly ITranslationService _translationService;
private readonly IContextAccessor _contextAccessor;
private readonly ICurrencyService _currencyService;
private readonly IPaymentService _paymentService;
private readonly IPaymentTransactionService _paymentTransactionService;
private readonly ICountryService _countryService;
private readonly IProductService _productService;
private readonly IMessageProviderService _messageProviderService;
private readonly IProductAttributeService _productAttributeService;
private readonly IGiftVoucherService _giftVoucherService;
private readonly IDownloadService _downloadService;
private readonly IStoreService _storeService;
private readonly IVendorService _vendorService;
private readonly ISalesEmployeeService _salesEmployeeService;
private readonly IAddressAttributeParser _addressAttributeParser;
private readonly IAddressAttributeService _addressAttributeService;
private readonly IAffiliateService _affiliateService;
private readonly IPictureService _pictureService;
private readonly ITaxService _taxService;
private readonly IMerchandiseReturnService _merchandiseReturnService;
private readonly ICustomerService _customerService;
private readonly IWarehouseService _warehouseService;
private readonly IProductAttributeFormatter _productAttributeFormatter;
private readonly IShoppingCartValidator _shoppingCartValidator;
private readonly CurrencySettings _currencySettings;
private readonly TaxSettings _taxSettings;
private readonly AddressSettings _addressSettings;
private readonly IOrderTagService _orderTagService;
private readonly IOrderStatusService _orderStatusService;
private readonly IMediator _mediator;
private readonly IEnumTranslationService _enumTranslationService;
private readonly IAdminDataScope<Order> _scope;
#endregion
#region Ctor
public OrderViewModelService(IOrderService orderService,
IPricingService priceCalculationService,
IDateTimeService dateTimeService,
IPriceFormatter priceFormatter,
IDiscountService discountService,
ITranslationService translationService,
IContextAccessor contextAccessor,
ICurrencyService currencyService,
IPaymentService paymentService,
IPaymentTransactionService paymentTransactionService,
ICountryService countryService,
IProductService productService,
IMessageProviderService messageProviderService,
IProductAttributeService productAttributeService,
IGiftVoucherService giftVoucherService,
IDownloadService downloadService,
IStoreService storeService,
IVendorService vendorService,
ISalesEmployeeService salesEmployeeService,
IAddressAttributeParser addressAttributeParser,
IAddressAttributeService addressAttributeService,
IAffiliateService affiliateService,
IPictureService pictureService,
ITaxService taxService,
IMerchandiseReturnService merchandiseReturnService,
ICustomerService customerService,
IWarehouseService warehouseService,
IShoppingCartValidator shoppingCartValidator,
CurrencySettings currencySettings,
TaxSettings taxSettings,
AddressSettings addressSettings,
IOrderTagService orderTagService,
IOrderStatusService orderStatusService,
IMediator mediator,
IProductAttributeFormatter productAttributeFormatter, IEnumTranslationService enumTranslationService,
IAdminDataScope<Order> scope)
{
_orderService = orderService;
_pricingService = priceCalculationService;
_dateTimeService = dateTimeService;
_priceFormatter = priceFormatter;
_discountService = discountService;
_translationService = translationService;
_contextAccessor = contextAccessor;
_currencyService = currencyService;
_paymentService = paymentService;
_paymentTransactionService = paymentTransactionService;
_countryService = countryService;
_productService = productService;
_messageProviderService = messageProviderService;
_productAttributeService = productAttributeService;
_giftVoucherService = giftVoucherService;
_downloadService = downloadService;
_storeService = storeService;
_vendorService = vendorService;
_salesEmployeeService = salesEmployeeService;
_addressAttributeParser = addressAttributeParser;
_addressAttributeService = addressAttributeService;
_affiliateService = affiliateService;
_pictureService = pictureService;
_taxService = taxService;
_merchandiseReturnService = merchandiseReturnService;
_warehouseService = warehouseService;
_shoppingCartValidator = shoppingCartValidator;
_currencySettings = currencySettings;
_taxSettings = taxSettings;
_addressSettings = addressSettings;
_customerService = customerService;
_orderTagService = orderTagService;
_orderStatusService = orderStatusService;
_mediator = mediator;
_productAttributeFormatter = productAttributeFormatter;
_enumTranslationService = enumTranslationService;
_scope = scope;
}
#endregion
public virtual async Task<OrderListModel> PrepareOrderListModel(
int? orderStatusId = null,
int? paymentStatusId = null,
int? shippingStatusId = null,
DateTime? startDate = null,
string storeId = null,
string code = null)
{
//order statuses
var statuses = await _orderStatusService.GetAll();
var model = new OrderListModel {
AvailableOrderStatuses = statuses
.Select(x => new SelectListItem { Value = x.StatusId.ToString(), Text = x.Name }).ToList()
};
model.AvailableOrderStatuses.Insert(0,
new SelectListItem { Text = _translationService.GetResource("Admin.Common.All"), Value = " " });
if (orderStatusId.HasValue)
{
//pre-select value?
var item = model.AvailableOrderStatuses.FirstOrDefault(x => x.Value == orderStatusId.Value.ToString());
if (item != null)
item.Selected = true;
}
//payment statuses
model.AvailablePaymentStatuses = _enumTranslationService.ToSelectList(PaymentStatus.Pending, false).ToList();
model.AvailablePaymentStatuses.Insert(0,
new SelectListItem { Text = _translationService.GetResource("Admin.Common.All"), Value = " " });
if (paymentStatusId.HasValue)
{
//pre-select value?
var item = model.AvailablePaymentStatuses.FirstOrDefault(x =>
x.Value == paymentStatusId.Value.ToString());
if (item != null)
item.Selected = true;
}
//order's tags
model.AvailableOrderTags.Add(new SelectListItem { Text = _translationService.GetResource("Admin.Common.All"), Value = " " });
foreach (var s in await _orderTagService.GetAllOrderTags())
model.AvailableOrderTags.Add(new SelectListItem { Text = s.Name, Value = s.Id });
//shipping statuses
model.AvailableShippingStatuses = _enumTranslationService.ToSelectList(ShippingStatus.ShippingNotRequired, false).ToList();
model.AvailableShippingStatuses.Insert(0,
new SelectListItem { Text = _translationService.GetResource("Admin.Common.All"), Value = " " });
if (shippingStatusId.HasValue)
{
//pre-select value?
var item = model.AvailableShippingStatuses.FirstOrDefault(x =>
x.Value == shippingStatusId.Value.ToString());
if (item != null)
item.Selected = true;
}
//stores
model.AvailableStores.Add(new SelectListItem { Text = _translationService.GetResource("Admin.Common.All"), Value = " " });
foreach (var s in (await _storeService.GetAllStores()).Where(x =>
x.Id == storeId || string.IsNullOrWhiteSpace(storeId)))
model.AvailableStores.Add(new SelectListItem { Text = s.Shortcut, Value = s.Id });
//vendors
model.AvailableVendors.Add(new SelectListItem { Text = _translationService.GetResource("Admin.Common.All"), Value = " " });
foreach (var v in await _vendorService.GetAllVendors(showHidden: true))
model.AvailableVendors.Add(new SelectListItem { Text = v.Name, Value = v.Id });
//warehouses
model.AvailableWarehouses.Add(new SelectListItem { Text = _translationService.GetResource("Admin.Common.All"), Value = " " });
foreach (var w in await _warehouseService.GetAllWarehouses())
model.AvailableWarehouses.Add(new SelectListItem { Text = w.Name, Value = w.Id });
//payment methods
model.AvailablePaymentMethods.Add(new SelectListItem { Text = _translationService.GetResource("Admin.Common.All"), Value = " " });
foreach (var pm in await _paymentService.LoadAllPaymentMethods())
model.AvailablePaymentMethods.Add(new SelectListItem { Text = pm.FriendlyName, Value = pm.SystemName });
//billing countries
foreach (var c in await _countryService.GetAllCountriesForBilling(showHidden: true))
model.AvailableCountries.Add(new SelectListItem { Text = c.Name, Value = c.Id });
model.AvailableCountries.Insert(0,
new SelectListItem { Text = _translationService.GetResource("Admin.Common.All"), Value = " " });
if (startDate.HasValue)
model.StartDate = startDate.Value;
if (!string.IsNullOrEmpty(code))
model.GoDirectlyToNumber = code;
return model;
}
public virtual async Task<(IEnumerable<OrderModel> orderModels, int totalCount)> PrepareOrderModel(
OrderListModel model, int pageIndex, int pageSize)
{
DateTime? startDateValue = model.StartDate == null
? null
: _dateTimeService.ConvertToUtcTime(model.StartDate.Value, _dateTimeService.CurrentTimeZone);
DateTime? endDateValue = model.EndDate == null
? null
: _dateTimeService.ConvertToUtcTime(model.EndDate.Value, _dateTimeService.CurrentTimeZone).AddDays(1);
int? orderStatus = model.OrderStatusId > 0 ? model.OrderStatusId : null;
var paymentStatus = model.PaymentStatusId > 0 ? (PaymentStatus?)model.PaymentStatusId : null;
var shippingStatus =
model.ShippingStatusId.HasValue ? (ShippingStatus?)model.ShippingStatusId : null;
var filterByProductId = "";
var product = await _productService.GetProductById(model.ProductId);
if (product != null)
filterByProductId = model.ProductId;
var salesEmployeeId = _contextAccessor.WorkContext.CurrentCustomer.SeId;
//load orders
var orders = await _orderService.SearchOrders(
model.StoreId,
model.VendorId,
model.CustomerId,
filterByProductId,
warehouseId: model.WarehouseId,
salesEmployeeId: salesEmployeeId,
paymentMethodSystemName: model.PaymentMethodSystemName,
createdFromUtc: startDateValue,
createdToUtc: endDateValue,
os: orderStatus,
ps: paymentStatus,
ss: shippingStatus,
billingEmail: model.BillingEmail,
billingLastName: model.BillingLastName,
billingCountryId: model.BillingCountryId,
orderGuid: model.OrderGuid,
orderCode: model.GoDirectlyToNumber,
pageIndex: pageIndex - 1,
pageSize: pageSize,
orderTagId: model.OrderTag);
var primaryStoreCurrency = await _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId);
if (primaryStoreCurrency == null)
throw new Exception("Cannot load primary store currency");
var status = await _orderStatusService.GetAll();
var items = new List<OrderModel>();
foreach (var x in orders)
{
var store = await _storeService.GetStoreById(x.StoreId);
var orderTotal = _priceFormatter.FormatPrice(x.OrderTotal,
await _currencyService.GetCurrencyByCode(x.CustomerCurrencyCode));
items.Add(new OrderModel {
Id = x.Id,
OrderNumber = x.OrderNumber,
Code = x.Code,
StoreName = store != null ? store.Shortcut : "Unknown",
OrderTotal = orderTotal,
CurrencyCode = x.CustomerCurrencyCode,
OrderStatus = status.FirstOrDefault(y => y.StatusId == x.OrderStatusId)?.Name,
OrderStatusId = x.OrderStatusId,
PaymentStatus = _enumTranslationService.GetTranslationEnum(x.PaymentStatusId),
ShippingStatus = _enumTranslationService.GetTranslationEnum(x.ShippingStatusId),
CustomerEmail = x.BillingAddress?.Email,
CustomerId = x.CustomerId,
CustomerFullName = $"{x.BillingAddress?.FirstName} {x.BillingAddress?.LastName}",
CreatedOn = _dateTimeService.ConvertToUserTime(x.CreatedOnUtc, DateTimeKind.Utc)
});
}
return (items, orders.TotalCount);
}
public virtual async Task PrepareOrderDetailsModel(OrderModel model, Order order)
{
ArgumentNullException.ThrowIfNull(order);
ArgumentNullException.ThrowIfNull(model);
model.Id = order.Id;
model.OrderNumber = order.OrderNumber;
model.Code = order.Code;
model.OrderStatusId = order.OrderStatusId;
model.OrderGuid = order.OrderGuid;
var status = await _orderStatusService.GetAll();
if (_scope.DefaultVendorId is null)
model.OrderStatuses =
status.Select(x => new SelectListItem { Value = x.StatusId.ToString(), Text = x.Name }).ToList();
model.OrderStatus = status.FirstOrDefault(x => x.StatusId == order.OrderStatusId)?.Name;
//cancelling runs the order's side effects (stock, gift vouchers) for the whole order, so it is
//offered to the panels that own the order, not to a vendor who sees only his own items
if (_scope.DefaultVendorId is null)
model.CanCancelOrder = await _mediator.Send(new CanCancelOrderQuery { Order = order });
var store = await _storeService.GetStoreById(order.StoreId);
model.StoreName = store != null ? store.Shortcut : "Unknown";
if (_scope.DefaultVendorId is null)
model.CustomerId = order.CustomerId;
model.UserFields = order.UserFields;
var customer = await _customerService.GetCustomerById(order.CustomerId);
if (customer != null)
model.CustomerInfo = !string.IsNullOrEmpty(customer.Email)
? customer.Email
: _translationService.GetResource($"{_scope.ResourceKeyPrefix}.Customers.Guest");
if (_scope.DefaultVendorId is null)
model.CustomerIp = order.CustomerIp;
model.VatNumber = order.VatNumber;
model.CreatedOn = _dateTimeService.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc);
model.TaxDisplayType = _taxSettings.TaxDisplayType;
if (_scope.DefaultVendorId is null)
{
if (!string.IsNullOrEmpty(order.AffiliateId))
{
var affiliate = await _affiliateService.GetAffiliateById(order.AffiliateId);
if (affiliate != null)
{
model.AffiliateId = affiliate.Id;
model.AffiliateName = affiliate.GetFullName();
}
}
}
if (_scope.DefaultVendorId is null)
{
if (!string.IsNullOrEmpty(order.SeId))
{
var salesEmployee = await _salesEmployeeService.GetSalesEmployeeById(order.SeId);
if (salesEmployee != null)
{
model.SalesEmployeeId = salesEmployee.Id;
model.SalesEmployeeName = salesEmployee.Name;
}
}
}
//order's tags
if (_scope.DefaultVendorId is null)
{
if (order.OrderTags.Any())
{
var tagsName = new List<string>();
foreach (var item in order.OrderTags)
{
var tag = await _orderTagService.GetOrderTagById(item);
if (tag != null)
tagsName.Add(tag.Name);
}
model.OrderTags = string.Join(",", tagsName);
}
}
model.CurrencyRate = order.CurrencyRate;
model.CurrencyCode = order.CustomerCurrencyCode;
#region Order totals
// primaryStoreCurrency/orderCurrency stay ungated: they're needed below (outside this
// gate) to format each OrderItemModel's unit price/discount/subtotal/commission, which
// Vendor's own OrderDetails.Products partial does render.
var primaryStoreCurrency = await _currencyService.GetCurrencyByCode(order.PrimaryCurrencyCode) ??
await _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId);
if (primaryStoreCurrency == null)
throw new Exception("Cannot load primary store currency");
var orderCurrency = await _currencyService.GetCurrencyByCode(order.CustomerCurrencyCode);
if (orderCurrency == null)
throw new Exception("Cannot load order currency");
// Vendor's original service never populated the rest of this block (subtotal, discount,
// shipping, tax, payment fee, order total, refund, loyalty points, gift vouchers,
// discount usage, profit) - matches the gating already applied above for CustomerId,
// CustomerIp, Affiliate, SalesEmployee, OrderTags and OrderStatuses (final review I2).
// None of Vendor's own Order partials render these fields today, so this has no visible
// behavior change for Vendor - it closes a latent exposure risk (e.g. a future shared
// view rendering merchant Profit to a vendor).
if (_scope.DefaultVendorId is null)
{
//subtotal
model.OrderSubtotalInclTax = _priceFormatter.FormatPrice(order.OrderSubtotalInclTax, orderCurrency);
model.OrderSubtotalExclTax = _priceFormatter.FormatPrice(order.OrderSubtotalExclTax, orderCurrency);
model.OrderSubtotalInclTaxValue = order.OrderSubtotalInclTax;
model.OrderSubtotalExclTaxValue = order.OrderSubtotalExclTax;
//discount (applied to order subtotal)
var orderSubtotalDiscountInclTaxStr =
_priceFormatter.FormatPrice(order.OrderSubTotalDiscountInclTax, orderCurrency);
var orderSubtotalDiscountExclTaxStr =
_priceFormatter.FormatPrice(order.OrderSubTotalDiscountExclTax, orderCurrency);
if (order.OrderSubTotalDiscountInclTax > 0)
model.OrderSubTotalDiscountInclTax = orderSubtotalDiscountInclTaxStr;
if (order.OrderSubTotalDiscountExclTax > 0)
model.OrderSubTotalDiscountExclTax = orderSubtotalDiscountExclTaxStr;
model.OrderSubTotalDiscountInclTaxValue = order.OrderSubTotalDiscountInclTax;
model.OrderSubTotalDiscountExclTaxValue = order.OrderSubTotalDiscountExclTax;
//shipping
model.OrderShippingInclTax = _priceFormatter.FormatPrice(order.OrderShippingInclTax, orderCurrency);
model.OrderShippingExclTax = _priceFormatter.FormatPrice(order.OrderShippingExclTax, orderCurrency);
model.OrderShippingInclTaxValue = order.OrderShippingInclTax;
model.OrderShippingExclTaxValue = order.OrderShippingExclTax;
//payment method additional fee
if (order.PaymentMethodAdditionalFeeInclTax > 0)
{
model.PaymentMethodAdditionalFeeInclTax =
_priceFormatter.FormatPrice(order.PaymentMethodAdditionalFeeInclTax, orderCurrency);
model.PaymentMethodAdditionalFeeExclTax =
_priceFormatter.FormatPrice(order.PaymentMethodAdditionalFeeExclTax, orderCurrency);
}
model.PaymentMethodAdditionalFeeInclTaxValue = order.PaymentMethodAdditionalFeeInclTax;
model.PaymentMethodAdditionalFeeExclTaxValue = order.PaymentMethodAdditionalFeeExclTax;
//tax
model.Tax = _priceFormatter.FormatPrice(order.OrderTax, orderCurrency);
var displayTaxRates = _taxSettings.DisplayTaxRates && order.OrderTaxes.Any();
var displayTax = !displayTaxRates;
foreach (var tr in order.OrderTaxes)
model.TaxRates.Add(new OrderModel.TaxRate {
Rate = _priceFormatter.FormatTaxRate(tr.Percent),
Value = _priceFormatter.FormatPrice(tr.Amount, orderCurrency)
});
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
model.TaxValue = order.OrderTax;
//model.TaxRatesValue = order.TaxRates;
//discount
if (order.OrderDiscount > 0)
model.OrderTotalDiscount = _priceFormatter.FormatPrice(-order.OrderDiscount, orderCurrency);
model.OrderTotalDiscountValue = order.OrderDiscount;
//gift vouchers
foreach (var gcuh in await _giftVoucherService.GetAllGiftVoucherUsageHistory(order.Id))
{
var giftVoucher = await _giftVoucherService.GetGiftVoucherById(gcuh.GiftVoucherId);
if (giftVoucher != null)
model.GiftVouchers.Add(new OrderModel.GiftVoucher {
CouponCode = giftVoucher.Code,
Amount = _priceFormatter.FormatPrice(-gcuh.UsedValue, orderCurrency)
});
}
//loyalty points
if (order.RedeemedLoyaltyPoints > 0)
{
model.RedeemedLoyaltyPoints = order.RedeemedLoyaltyPoints;
model.RedeemedLoyaltyPointsAmount =
_priceFormatter.FormatPrice(-order.RedeemedLoyaltyPointsAmount, orderCurrency);
}
//total
model.OrderTotal = _priceFormatter.FormatPrice(order.OrderTotal, orderCurrency);
model.OrderTotalValue = order.OrderTotal;
//refunded amount
if (order.RefundedAmount > 0)
model.RefundedAmount = _priceFormatter.FormatPrice(order.RefundedAmount, orderCurrency);
var suggestedRefundedAmount = order.OrderItems.Sum(x => x.CancelAmount);
if (suggestedRefundedAmount > 0)
model.SuggestedRefundedAmount = _priceFormatter.FormatPrice(suggestedRefundedAmount, orderCurrency);
//used discounts
var duh = await _mediator.Send(new GetDiscountUsageHistoryQuery { OrderId = order.Id });
foreach (var d in duh)
{
var discount = await _discountService.GetDiscountById(d.DiscountId);
if (discount != null)
model.UsedDiscounts.Add(new OrderModel.UsedDiscountModel {
DiscountId = d.DiscountId,
DiscountName = discount.Name
});
}
//profit
var productCost = order.OrderItems.Sum(orderItem => orderItem.OriginalProductCost * orderItem.Quantity);
if (order.CurrencyRate > 0)
{
var profit = Convert.ToDouble(order.OrderTotal / order.CurrencyRate -
order.OrderShippingExclTax / order.CurrencyRate -
order.OrderTax / order.CurrencyRate - productCost);
model.Profit = _priceFormatter.FormatPrice(profit, primaryStoreCurrency);
}
if (order.PrimaryCurrencyCode != order.CustomerCurrencyCode)
{
model.OrderTotal +=
$" ({_priceFormatter.FormatPrice(order.OrderTotal / order.CurrencyRate, primaryStoreCurrency)})";
model.OrderSubtotalInclTax +=
$" ({_priceFormatter.FormatPrice(order.OrderSubtotalInclTax / order.CurrencyRate, primaryStoreCurrency)})";
model.OrderSubtotalExclTax +=
$" ({_priceFormatter.FormatPrice(order.OrderSubtotalExclTax / order.CurrencyRate, primaryStoreCurrency)})";
//discount (applied to order subtotal)
if (order.OrderSubTotalDiscountInclTax > 0)
model.OrderSubTotalDiscountInclTax +=
$" ({_priceFormatter.FormatPrice(order.OrderSubTotalDiscountInclTax / order.CurrencyRate, primaryStoreCurrency)})";
if (order.OrderSubTotalDiscountExclTax > 0)
model.OrderSubTotalDiscountExclTax +=
$" ({_priceFormatter.FormatPrice(order.OrderSubTotalDiscountExclTax / order.CurrencyRate, primaryStoreCurrency)})";
//shipping
model.OrderShippingInclTax +=
$" ({_priceFormatter.FormatPrice(order.OrderShippingInclTax / order.CurrencyRate, primaryStoreCurrency)})";
model.OrderShippingExclTax +=
$" ({_priceFormatter.FormatPrice(order.OrderShippingExclTax / order.CurrencyRate, primaryStoreCurrency)})";
//payment method additional fee
if (order.PaymentMethodAdditionalFeeInclTax > 0)
{
model.PaymentMethodAdditionalFeeInclTax +=
$" ({_priceFormatter.FormatPrice(order.PaymentMethodAdditionalFeeInclTax / order.CurrencyRate, primaryStoreCurrency)})";
model.PaymentMethodAdditionalFeeExclTax +=
$" ({_priceFormatter.FormatPrice(order.PaymentMethodAdditionalFeeExclTax / order.CurrencyRate, primaryStoreCurrency)})";
}
model.Tax +=
$" ({_priceFormatter.FormatPrice(order.OrderTax / order.CurrencyRate, primaryStoreCurrency)})";
//refunded amount
if (order.RefundedAmount > 0)
model.RefundedAmount +=
$" ({_priceFormatter.FormatPrice(order.RefundedAmount / order.CurrencyRate, primaryStoreCurrency)})";
}
#endregion
}
#region Payment info
//payment method info
var pm = _paymentService.LoadPaymentMethodBySystemName(order.PaymentMethodSystemName);
model.PaymentMethod = pm != null ? pm.FriendlyName : order.PaymentMethodSystemName;
model.PaymentStatus = _enumTranslationService.GetTranslationEnum(order.PaymentStatusId);
model.PaymentStatusEnum = order.PaymentStatusId;
// Vendor's original service never populated PaymentTransactionId, PrimaryStoreCurrencyCode
// or MaxAmountToRefund either - same gate as the totals block above (final review I2).
if (_scope.DefaultVendorId is null)
{
var pt = await _paymentTransactionService.GetOrderByGuid(order.OrderGuid);
if (pt != null)
model.PaymentTransactionId = pt.Id;
model.PrimaryStoreCurrencyCode = order.PrimaryCurrencyCode;
model.MaxAmountToRefund = order.OrderTotal - order.RefundedAmount;
}
#endregion
#region Billing & shipping info
model.BillingAddress = await order.BillingAddress.ToModel(_countryService);
model.BillingAddress.FormattedCustomAddressAttributes =
await _addressAttributeParser.FormatAttributes(_contextAccessor.WorkContext.WorkingLanguage,
order.BillingAddress.Attributes);
model.BillingAddress.NameEnabled = _addressSettings.NameEnabled;
model.BillingAddress.FirstNameEnabled = true;
model.BillingAddress.FirstNameRequired = true;
model.BillingAddress.LastNameEnabled = true;
model.BillingAddress.LastNameRequired = true;
model.BillingAddress.EmailEnabled = true;
model.BillingAddress.EmailRequired = true;
model.BillingAddress.CompanyEnabled = _addressSettings.CompanyEnabled;
model.BillingAddress.CompanyRequired = _addressSettings.CompanyRequired;
model.BillingAddress.VatNumberEnabled = _addressSettings.VatNumberEnabled;
model.BillingAddress.VatNumberRequired = _addressSettings.VatNumberRequired;
model.BillingAddress.CountryEnabled = _addressSettings.CountryEnabled;
model.BillingAddress.StateProvinceEnabled = _addressSettings.StateProvinceEnabled;
model.BillingAddress.CityEnabled = _addressSettings.CityEnabled;
model.BillingAddress.CityRequired = _addressSettings.CityRequired;
model.BillingAddress.StreetAddressEnabled = _addressSettings.StreetAddressEnabled;
model.BillingAddress.StreetAddressRequired = _addressSettings.StreetAddressRequired;
model.BillingAddress.StreetAddress2Enabled = _addressSettings.StreetAddress2Enabled;
model.BillingAddress.StreetAddress2Required = _addressSettings.StreetAddress2Required;
model.BillingAddress.ZipPostalCodeEnabled = _addressSettings.ZipPostalCodeEnabled;
model.BillingAddress.ZipPostalCodeRequired = _addressSettings.ZipPostalCodeRequired;
model.BillingAddress.PhoneEnabled = _addressSettings.PhoneEnabled;
model.BillingAddress.PhoneRequired = _addressSettings.PhoneRequired;
model.BillingAddress.FaxEnabled = _addressSettings.FaxEnabled;
model.BillingAddress.FaxRequired = _addressSettings.FaxRequired;
model.BillingAddress.NoteEnabled = _addressSettings.NoteEnabled;
// Vendor's original service never populated ShippingStatus - same gate as the totals
// block above (final review I2).
if (_scope.DefaultVendorId is null)
model.ShippingStatus = _enumTranslationService.GetTranslationEnum(order.ShippingStatusId);
if (order.ShippingStatusId != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.PickUpInStore = order.PickUpInStore;
if (!order.PickUpInStore)
{
if (order.ShippingAddress != null)
{
model.ShippingAddress = await order.ShippingAddress.ToModel(_countryService);
model.ShippingAddress.FormattedCustomAddressAttributes =
await _addressAttributeParser.FormatAttributes(_contextAccessor.WorkContext.WorkingLanguage,
order.ShippingAddress.Attributes);
model.ShippingAddress.NameEnabled = _addressSettings.NameEnabled;
model.ShippingAddress.FirstNameEnabled = true;
model.ShippingAddress.FirstNameRequired = true;
model.ShippingAddress.LastNameEnabled = true;
model.ShippingAddress.LastNameRequired = true;
model.ShippingAddress.EmailEnabled = true;
model.ShippingAddress.EmailRequired = true;
model.ShippingAddress.CompanyEnabled = _addressSettings.CompanyEnabled;
model.ShippingAddress.CompanyRequired = _addressSettings.CompanyRequired;
model.ShippingAddress.VatNumberEnabled = _addressSettings.VatNumberEnabled;
model.ShippingAddress.VatNumberRequired = _addressSettings.VatNumberRequired;
model.ShippingAddress.CountryEnabled = _addressSettings.CountryEnabled;
model.ShippingAddress.StateProvinceEnabled = _addressSettings.StateProvinceEnabled;
model.ShippingAddress.CityEnabled = _addressSettings.CityEnabled;
model.ShippingAddress.CityRequired = _addressSettings.CityRequired;
model.ShippingAddress.StreetAddressEnabled = _addressSettings.StreetAddressEnabled;
model.ShippingAddress.StreetAddressRequired = _addressSettings.StreetAddressRequired;
model.ShippingAddress.StreetAddress2Enabled = _addressSettings.StreetAddress2Enabled;
model.ShippingAddress.StreetAddress2Required = _addressSettings.StreetAddress2Required;
model.ShippingAddress.ZipPostalCodeEnabled = _addressSettings.ZipPostalCodeEnabled;
model.ShippingAddress.ZipPostalCodeRequired = _addressSettings.ZipPostalCodeRequired;
model.ShippingAddress.PhoneEnabled = _addressSettings.PhoneEnabled;
model.ShippingAddress.PhoneRequired = _addressSettings.PhoneRequired;
model.ShippingAddress.FaxEnabled = _addressSettings.FaxEnabled;
model.ShippingAddress.FaxRequired = _addressSettings.FaxRequired;
model.ShippingAddress.NoteEnabled = _addressSettings.NoteEnabled;
model.ShippingAddressGoogleMapsUrl =
$"https://maps.google.com/maps?f=q&hl=en&ie=UTF8&oe=UTF8&geocode=&q={WebUtility.UrlEncode(order.ShippingAddress.Address1 + " " + order.ShippingAddress.ZipPostalCode + " " + order.ShippingAddress.City + " " + (!string.IsNullOrEmpty(order.ShippingAddress.CountryId) ? (await _countryService.GetCountryById(order.ShippingAddress.CountryId))?.Name : ""))}";
}
}
else
{
if (order.PickupPoint is { Address: not null })
{
model.PickupAddress = await order.PickupPoint.Address.ToModel(_countryService);
var country = await _countryService.GetCountryById(order.PickupPoint.Address.CountryId);
if (country != null)
model.PickupAddress.CountryName = country.Name;
}
}
model.ShippingMethod = order.ShippingMethod;
model.ShippingAdditionDescription = order.ShippingOptionAttributeDescription;
model.CanAddNewShipments = false;
foreach (var orderItem in order.OrderItems)
{
//we can ship only shippable products
if (!orderItem.IsShipEnabled)
continue;
if (orderItem.OpenQty <= 0)
continue;
model.CanAddNewShipments = true;
}
}
#endregion
#region Products
model.CheckoutAttributeInfo = order.CheckoutAttributeDescription;
var hasDownloadableItems = false;
var products = _scope.FilterOrderItems(order.OrderItems);
foreach (var orderItem in products)
{
var product = await _productService.GetProductByIdIncludeArch(orderItem.ProductId);
if (product == null) continue;
if (product.IsDownload)
hasDownloadableItems = true;
var orderItemModel = new OrderModel.OrderItemModel {
Id = orderItem.Id,
ProductId = orderItem.ProductId,
ProductName = product.Name,
Sku = orderItem.Sku,
Quantity = orderItem.Quantity,
OpenQty = orderItem.OpenQty,
CancelQty = orderItem.CancelQty,
ReturnQty = orderItem.ReturnQty,
ShipQty = orderItem.ShipQty,
IsShipEnabled = orderItem.IsShipEnabled,
Status = orderItem.Status,
IsGiftVoucher = product.IsGiftVoucher,
IsDownload = product.IsDownload,
DownloadCount = orderItem.DownloadCount,
DownloadActivationType = product.DownloadActivationTypeId,
IsDownloadActivated = orderItem.IsDownloadActivated
};
//picture
var orderItemPicture = await GetProductPicture(product, orderItem.Attributes);
orderItemModel.PictureThumbnailUrl = await _pictureService.GetPictureUrl(orderItemPicture, 75);
//license file
if (!string.IsNullOrEmpty(orderItem.LicenseDownloadId))
{
var licenseDownload = await _downloadService.GetDownloadById(orderItem.LicenseDownloadId);
if (licenseDownload != null) orderItemModel.LicenseDownloadGuid = licenseDownload.DownloadGuid;
}
//vendor
var vendor = await _vendorService.GetVendorById(orderItem.VendorId);
orderItemModel.VendorName = vendor != null ? vendor.Name : "";
//unit price
orderItemModel.UnitPriceInclTaxValue = orderItem.UnitPriceInclTax;
orderItemModel.UnitPriceExclTaxValue = orderItem.UnitPriceExclTax;
orderItemModel.UnitPriceInclTax =
_priceFormatter.FormatPrice(orderItem.UnitPriceInclTax, orderCurrency);
orderItemModel.UnitPriceExclTax =
_priceFormatter.FormatPrice(orderItem.UnitPriceExclTax, orderCurrency);
//discounts
orderItemModel.DiscountInclTaxValue = orderItem.DiscountAmountInclTax;
orderItemModel.DiscountExclTaxValue = orderItem.DiscountAmountExclTax;
orderItemModel.DiscountInclTax =
_priceFormatter.FormatPrice(orderItem.DiscountAmountInclTax, orderCurrency);
orderItemModel.DiscountExclTax =
_priceFormatter.FormatPrice(orderItem.DiscountAmountExclTax, orderCurrency);
//subtotal
orderItemModel.SubTotalInclTaxValue = orderItem.PriceInclTax;
orderItemModel.SubTotalExclTaxValue = orderItem.PriceExclTax;
orderItemModel.SubTotalInclTax = _priceFormatter.FormatPrice(orderItem.PriceInclTax, orderCurrency);
orderItemModel.SubTotalExclTax = _priceFormatter.FormatPrice(orderItem.PriceExclTax, orderCurrency);
if (order.PrimaryCurrencyCode != order.CustomerCurrencyCode)
{
orderItemModel.UnitPriceInclTax +=
$" ({_priceFormatter.FormatPrice(orderItem.UnitPriceInclTax / order.CurrencyRate, primaryStoreCurrency)})";
orderItemModel.UnitPriceExclTax +=
$" ({_priceFormatter.FormatPrice(orderItem.UnitPriceExclTax / order.CurrencyRate, primaryStoreCurrency)})";
orderItemModel.DiscountInclTax +=
$" ({_priceFormatter.FormatPrice(orderItem.DiscountAmountInclTax / order.CurrencyRate, primaryStoreCurrency)})";
orderItemModel.DiscountExclTax +=
$" ({_priceFormatter.FormatPrice(orderItem.DiscountAmountExclTax / order.CurrencyRate, primaryStoreCurrency)})";
orderItemModel.SubTotalInclTax +=
$" ({_priceFormatter.FormatPrice(orderItem.PriceInclTax / order.CurrencyRate, primaryStoreCurrency)})";
orderItemModel.SubTotalExclTax +=
$" ({_priceFormatter.FormatPrice(orderItem.PriceExclTax / order.CurrencyRate, primaryStoreCurrency)})";
}
// commission
orderItemModel.CommissionValue = orderItem.Commission;
orderItemModel.Commission = _priceFormatter.FormatPrice(orderItem.Commission, orderCurrency);
orderItemModel.AttributeInfo = orderItem.AttributeDescription;
if (product.IsRecurring)
orderItemModel.RecurringInfo = string.Format(
_translationService.GetResource("Admin.Orders.Products.RecurringPeriod"),
product.RecurringCycleLength,
_enumTranslationService.GetTranslationEnum(product.RecurringCyclePeriodId),
product.RecurringTotalCycles);
//merchandise returns
orderItemModel.MerchandiseReturnIds =
(await _merchandiseReturnService.SearchMerchandiseReturns(orderItemId: orderItem.Id))
.Select(rr => rr.Id).ToList();
//gift vouchers
orderItemModel.PurchasedGiftVoucherIds =
(await _giftVoucherService.GetGiftVouchersByPurchasedWithOrderItemId(orderItem.Id))
.Select(gc => gc.Id).ToList();
model.Items.Add(orderItemModel);
}
model.HasDownloadableProducts = hasDownloadableItems;
#endregion
}
public virtual async Task<OrderModel.AddOrderProductModel> PrepareAddOrderProductModel(Order order)
{
var model = new OrderModel.AddOrderProductModel {
OrderId = order.Id,
OrderNumber = order.OrderNumber,
//product types
AvailableProductTypes = _enumTranslationService.ToSelectList(ProductType.SimpleProduct, false).ToList()
};
model.AvailableProductTypes.Insert(0,
new SelectListItem { Text = _translationService.GetResource("Admin.Common.All"), Value = "0" });
return await Task.FromResult(model);
}
public virtual async Task<OrderModel.AddOrderProductModel.ProductDetailsModel> PrepareAddProductToOrderModel(
Order order, string productId)
{
var product = await _productService.GetProductById(productId);
if (product == null)
throw new ArgumentException("No product found with the specified id");
var customer = await _customerService.GetCustomerById(order.CustomerId);
var currency = await _currencyService.GetCurrencyByCode(order.CustomerCurrencyCode);
var store = await _storeService.GetStoreById(order.StoreId);
var presetQty = 1;
var presetPrice = (await _pricingService.GetFinalPrice(product, customer, store, currency, 0, true, presetQty))
.finalPrice;
var productPrice = await _taxService.GetProductPrice(product, presetPrice, true, customer, store);
var presetPriceInclTax = productPrice.productprice;
var presetPriceExclTax =
(await _taxService.GetProductPrice(product, presetPrice, false, customer, store)).productprice;
var model = new OrderModel.AddOrderProductModel.ProductDetailsModel {
ProductId = product.Id,
OrderId = order.Id,
OrderNumber = order.OrderNumber,
Name = product.Name,
ProductType = product.ProductTypeId,
UnitPriceExclTax = presetPriceExclTax,
UnitPriceInclTax = presetPriceInclTax,
Quantity = presetQty,
TaxRate = productPrice.taxRate
};
//attributes
var attributes = product.ProductAttributeMappings;
foreach (var attribute in attributes)
{
var productAttribute =
await _productAttributeService.GetProductAttributeById(attribute.ProductAttributeId);
var attributeModel = new OrderModel.AddOrderProductModel.ProductAttributeModel {
Id = attribute.Id,
ProductAttributeId = attribute.ProductAttributeId,
Name = productAttribute.Name,
TextPrompt = attribute.TextPrompt,
IsRequired = attribute.IsRequired,
AttributeControlType = attribute.AttributeControlTypeId
};
if (attribute.ShouldHaveValues())
{
//values
var attributeValues = attribute.ProductAttributeValues;
foreach (var attributeValue in attributeValues)
{
var attributeValueModel = new OrderModel.AddOrderProductModel.ProductAttributeValueModel {
Id = attributeValue.Id,
Name = attributeValue.Name,
IsPreSelected = attributeValue.IsPreSelected
};
attributeModel.Values.Add(attributeValueModel);
}
}
model.ProductAttributes.Add(attributeModel);
}
//gift voucher
model.GiftVoucher.IsGiftVoucher = product.IsGiftVoucher;
if (model.GiftVoucher.IsGiftVoucher) model.GiftVoucher.GiftVoucherType = product.GiftVoucherTypeId;
return model;
}
public virtual async Task<OrderAddressModel> PrepareOrderAddressModel(Order order, Address address)
{
var model = new OrderAddressModel {
OrderId = order.Id,
Address = await address.ToModel(_countryService)
};
model.Address.Id = address.Id;
model.Address.NameEnabled = _addressSettings.NameEnabled;
model.Address.FirstNameEnabled = true;
model.Address.FirstNameRequired = true;
model.Address.LastNameEnabled = true;
model.Address.LastNameRequired = true;
model.Address.EmailEnabled = true;
model.Address.EmailRequired = true;
model.Address.CompanyEnabled = _addressSettings.CompanyEnabled;
model.Address.CompanyRequired = _addressSettings.CompanyRequired;
model.Address.VatNumberEnabled = _addressSettings.VatNumberEnabled;
model.Address.VatNumberRequired = _addressSettings.VatNumberRequired;
model.Address.CountryEnabled = _addressSettings.CountryEnabled;
model.Address.StateProvinceEnabled = _addressSettings.StateProvinceEnabled;
model.Address.CityEnabled = _addressSettings.CityEnabled;
model.Address.CityRequired = _addressSettings.CityRequired;
model.Address.StreetAddressEnabled = _addressSettings.StreetAddressEnabled;
model.Address.StreetAddressRequired = _addressSettings.StreetAddressRequired;
model.Address.StreetAddress2Enabled = _addressSettings.StreetAddress2Enabled;
model.Address.StreetAddress2Required = _addressSettings.StreetAddress2Required;
model.Address.ZipPostalCodeEnabled = _addressSettings.ZipPostalCodeEnabled;
model.Address.ZipPostalCodeRequired = _addressSettings.ZipPostalCodeRequired;
model.Address.PhoneEnabled = _addressSettings.PhoneEnabled;
model.Address.PhoneRequired = _addressSettings.PhoneRequired;
model.Address.FaxEnabled = _addressSettings.FaxEnabled;
model.Address.FaxRequired = _addressSettings.FaxRequired;
model.Address.NoteEnabled = _addressSettings.NoteEnabled;
model.Address.AddressTypeEnabled = _addressSettings.AddressTypeEnabled;
//countries
model.Address.AvailableCountries.Add(new SelectListItem { Text = _translationService.GetResource("Admin.Address.SelectCountry"), Value = "" });
foreach (var c in await _countryService.GetAllCountries(showHidden: true))
model.Address.AvailableCountries.Add(new SelectListItem { Text = c.Name, Value = c.Id, Selected = c.Id == address.CountryId });
//states
var states = !string.IsNullOrEmpty(address.CountryId)
? (await _countryService.GetCountryById(address.CountryId))?.StateProvinces
: new List<StateProvince>();
if (states?.Count > 0)
foreach (var s in states)
model.Address.AvailableStates.Add(new SelectListItem { Text = s.Name, Value = s.Id, Selected = s.Id == address.StateProvinceId });
//customer attribute services
await model.Address.PrepareCustomAddressAttributes(address, _addressAttributeService,
_addressAttributeParser);
return model;
}
public virtual async Task<IList<OrderModel.OrderNote>> PrepareOrderNotes(Order order)
{
//order notes
var orderNoteModels = new List<OrderModel.OrderNote>();
foreach (var orderNote in (await _orderService.GetOrderNotes(order.Id))
.OrderByDescending(on => on.CreatedOnUtc))
{
var download = await _downloadService.GetDownloadById(orderNote.DownloadId);
orderNoteModels.Add(new OrderModel.OrderNote {
Id = orderNote.Id,
OrderId = order.Id,
DownloadId = string.IsNullOrEmpty(orderNote.DownloadId) ? "" : orderNote.DownloadId,
DownloadGuid = download?.DownloadGuid ?? Guid.Empty,
DisplayToCustomer = orderNote.DisplayToCustomer,
Note = orderNote.Note,
CreatedOn = _dateTimeService.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc),
CreatedByCustomer = orderNote.CreatedByCustomer
});
}
return orderNoteModels;
}
public virtual async Task InsertOrderNote(Order order, string downloadId, bool displayToCustomer,
string message)
{
var orderNote = new OrderNote {
DisplayToCustomer = displayToCustomer,
Note = message,
DownloadId = downloadId,
OrderId = order.Id
};
await _orderService.InsertOrderNote(orderNote);
//new order notification
if (displayToCustomer)
//email
await _messageProviderService.SendNewOrderNoteAddedCustomerMessage(order, orderNote);
}
public virtual async Task DeleteOrderNote(Order order, string id)
{
var orderNote = (await _orderService.GetOrderNotes(order.Id)).FirstOrDefault(on => on.Id == id);
if (orderNote == null)
throw new ArgumentException("No order note found with the specified id");
orderNote.OrderId = order.Id;
await _orderService.DeleteOrderNote(orderNote);
//delete an old "attachment" file
if (!string.IsNullOrEmpty(orderNote.DownloadId))
{
var attachment = await _downloadService.GetDownloadById(orderNote.DownloadId);
if (attachment != null)
await _downloadService.DeleteDownload(attachment);
}
}
public virtual async Task<Address> UpdateOrderAddress(Order order, Address address, OrderAddressModel model,
List<CustomAttribute> customAttributes)
{
address = model.Address.ToEntity(address);
address.Attributes = customAttributes;
await _orderService.UpdateOrder(order);
//add a note
await _orderService.InsertOrderNote(new OrderNote {
Note = "Address has been edited",
DisplayToCustomer = false,
OrderId = order.Id
});
return address;
}
public virtual async Task<IList<string>> AddProductToOrderDetails(AddProductToOrderModel model)
{
var order = await _orderService.GetOrderById(model.OrderId);
var product = await _productService.GetProductById(model.ProductId);
var customer = await _customerService.GetCustomerById(order.CustomerId);
var warnings = new List<string>();
var customattributes = new List<CustomAttribute>();
#region Product attributes
var attributes = product.ProductAttributeMappings;
foreach (var attribute in attributes)
switch (attribute.AttributeControlTypeId)
{
case AttributeControlType.DropdownList:
case AttributeControlType.RadioList:
case AttributeControlType.ColorSquares:
case AttributeControlType.ImageSquares:
{
var ctrlAttributes = model.SelectedAttributes.FirstOrDefault(x => x.Key == attribute.Id)?.Value;
if (!string.IsNullOrEmpty(ctrlAttributes))
customattributes = ProductExtensions.AddProductAttribute(customattributes,
attribute, ctrlAttributes).ToList();
}
break;
case AttributeControlType.Checkboxes:
{
var cblAttributes = model.SelectedAttributes.FirstOrDefault(x => x.Key == attribute.Id)?.Value;
if (!string.IsNullOrEmpty(cblAttributes))
foreach (var item in cblAttributes
.Split([','], StringSplitOptions.RemoveEmptyEntries))
customattributes = ProductExtensions.AddProductAttribute(
customattributes,
attribute, item).ToList();
}
break;
case AttributeControlType.ReadonlyCheckboxes:
{
//load read-only (already server-side selected) values
var attributeValues = attribute.ProductAttributeValues;
foreach (var selectedAttributeId in attributeValues
.Where(v => v.IsPreSelected)
.Select(v => v.Id)
.ToList())
customattributes = ProductExtensions.AddProductAttribute(customattributes,
attribute, selectedAttributeId).ToList();
}
break;
case AttributeControlType.TextBox:
case AttributeControlType.MultilineTextbox:
case AttributeControlType.FileUpload:
{
var ctrlAttributes = model.SelectedAttributes.FirstOrDefault(x => x.Key == attribute.Id)?.Value;
if (!string.IsNullOrEmpty(ctrlAttributes))
{
var enteredText = ctrlAttributes.Trim();
customattributes = ProductExtensions.AddProductAttribute(customattributes, attribute, enteredText).ToList();
}
}
break;
}
//validate conditional attributes (if specified)
foreach (var attribute in attributes)
{
var conditionMet = product.IsConditionMet(attribute, customattributes);
if (conditionMet.HasValue && !conditionMet.Value)
customattributes = ProductExtensions
.RemoveProductAttribute(customattributes, attribute).ToList();
}
#endregion
#region Gift vouchers
var recipientName = model.Giftvoucher?.RecipientName;
var recipientEmail = model.Giftvoucher?.RecipientEmail;
var senderName = model.Giftvoucher?.SenderName;
var senderEmail = model.Giftvoucher?.SenderEmail;
var giftVoucherMessage = model.Giftvoucher?.Message;
if (product.IsGiftVoucher)
customattributes = GiftVoucherExtensions.AddGiftVoucherAttribute(customattributes,
recipientName, recipientEmail, senderName, senderEmail, giftVoucherMessage).ToList();
#endregion
//warnings
var shoppingCartItem = new ShoppingCartItem {
ShoppingCartTypeId = ShoppingCartType.ShoppingCart,
Quantity = model.Quantity,
WarehouseId = product.WarehouseId,
Attributes = customattributes
};
warnings.AddRange(
await _shoppingCartValidator.GetShoppingCartItemAttributeWarnings(customer, product, shoppingCartItem));
warnings.AddRange(
await _shoppingCartValidator.GetShoppingCartItemGiftVoucherWarnings(customer, product,
shoppingCartItem));
if (warnings.Count == 0)
{
var attributeDescription =
await _productAttributeFormatter.FormatAttributes(product, customattributes, customer);
//save item
var orderItem = new OrderItem {
OrderItemGuid = Guid.NewGuid(),
ProductId = product.Id,
VendorId = product.VendorId,
WarehouseId = product.WarehouseId,
Sku = product.FormatSku(customattributes),
SeId = order.SeId,
UnitPriceInclTax = model.UnitPriceExclTax,
UnitPriceExclTax = model.UnitPriceInclTax,
PriceInclTax = Math.Round(model.UnitPriceInclTax * model.Quantity, 2),
PriceExclTax = Math.Round(model.UnitPriceExclTax * model.Quantity, 2),
TaxRate = model.TaxRate,
OriginalProductCost = await _pricingService.GetProductCost(product, customattributes),
AttributeDescription = attributeDescription,
Attributes = customattributes,
Quantity = model.Quantity,
OpenQty = model.Quantity,
DiscountAmountInclTax = 0,
DiscountAmountExclTax = 0,
DownloadCount = 0,
IsDownloadActivated = false,
LicenseDownloadId = "",
IsShipEnabled = product.IsShipEnabled,
CreatedOnUtc = DateTime.UtcNow
};
await _mediator.Send(new InsertOrderItemCommand { Order = order, OrderItem = orderItem, Product = product });
}
return warnings;
}
public virtual async Task<IList<Order>> PrepareOrders(OrderListModel model)
{
DateTime? startDateValue = model.StartDate == null
? null
: _dateTimeService.ConvertToUtcTime(model.StartDate.Value, _dateTimeService.CurrentTimeZone);
DateTime? endDateValue = model.EndDate == null
? null
: _dateTimeService.ConvertToUtcTime(model.EndDate.Value, _dateTimeService.CurrentTimeZone).AddDays(1);
int? orderStatus = model.OrderStatusId > 0 ? model.OrderStatusId : null;
var paymentStatus = model.PaymentStatusId > 0 ? (PaymentStatus?)model.PaymentStatusId : null;
var shippingStatus =
model.ShippingStatusId > 0 ? (ShippingStatus?)model.ShippingStatusId : null;
var filterByProductId = "";
var product = await _productService.GetProductById(model.ProductId);
if (product != null)
filterByProductId = model.ProductId;
var salesEmployeeId = _contextAccessor.WorkContext.CurrentCustomer.SeId;
//load orders
var orders = await _orderService.SearchOrders(model.StoreId,
model.VendorId,
productId: filterByProductId,
salesEmployeeId: salesEmployeeId,
warehouseId: model.WarehouseId,
paymentMethodSystemName: model.PaymentMethodSystemName,
createdFromUtc: startDateValue,
createdToUtc: endDateValue,
os: orderStatus,
ps: paymentStatus,
ss: shippingStatus,
billingEmail: model.BillingEmail,
billingLastName: model.BillingLastName,
billingCountryId: model.BillingCountryId,
orderGuid: model.OrderGuid);
return orders;
}
/// <summary>
/// Save order's tag by id
/// </summary>
/// <param name="order">Order identifier</param>
/// <param name="orderTags">Order's tag identifier</param>
/// <returns>Order's tag</returns>
public virtual async Task SaveOrderTags(Order order, string orderTags)
{
ArgumentNullException.ThrowIfNull(order);
//order's tags
var existingOrderTags = new List<string>();
foreach (var item in order.OrderTags)
{
var tag = await _orderTagService.GetOrderTagById(item);
if (tag != null)
existingOrderTags.Add(tag.Name);
}
var newOrderTags = ParseOrderTagsToList(orderTags);
// compare
var orderTagsToRemove = existingOrderTags.Except(newOrderTags);
foreach (var orderTag in orderTagsToRemove)
{
var ot = await _orderTagService.GetOrderTagByName(orderTag);
if (ot != null) await _orderTagService.DetachOrderTag(ot.Id, order.Id);
}
var allOrderTags = await _orderTagService.GetAllOrderTags();
foreach (var newOrderTag in newOrderTags)
{
OrderTag orderTag;
var orderTag2 = allOrderTags.FirstOrDefault(o => o.Name == newOrderTag);
if (orderTag2 == null)
{
orderTag = new OrderTag { Name = newOrderTag, Count = 0 };
await _orderTagService.InsertOrderTag(orderTag);
}
else
{
orderTag = orderTag2;
}
if (!order.OrderTagExists(orderTag)) await _orderTagService.AttachOrderTag(orderTag.Id, order.Id);
}
}
private static IList<string> ParseOrderTagsToList(string orderTags)
{
var result = new List<string>();
if (!string.IsNullOrWhiteSpace(orderTags))
{
var values = orderTags.Split([','], StringSplitOptions.RemoveEmptyEntries);
foreach (var val1 in values)
if (!string.IsNullOrEmpty(val1.Trim()))
result.Add(val1.Trim());
}
return result;
}
private async Task<Picture> GetProductPicture(Product product, IList<CustomAttribute> attributes)
{
ArgumentNullException.ThrowIfNull(product);
Picture picture = null;
if (attributes != null && attributes.Any())
{
var comb = product.FindProductAttributeCombination(attributes);
if (comb != null)
if (!string.IsNullOrEmpty(comb.PictureId))
{
var combPicture = await _pictureService.GetPictureById(comb.PictureId);
if (combPicture != null) picture = combPicture;
}
if (picture == null)
{
var attributeValues = product.ParseProductAttributeValues(attributes);
foreach (var attributeValue in attributeValues)
{
var attributePicture = await _pictureService.GetPictureById(attributeValue.PictureId);
if (attributePicture != null)
{
picture = attributePicture;
break;
}
}
}
}
if (picture == null)
{
var pp = product.ProductPictures.OrderByDescending(p => p.IsDefault)
.ThenBy(p => p.DisplayOrder)
.FirstOrDefault();
if (pp != null)
picture = await _pictureService.GetPictureById(pp.PictureId);
}
return picture;
}
}