protected virtual LightLineItemDetailViewModel GetLightLineItemDetailViewModel(CreateLineItemDetailViewModelParam param)
{
param.PreMapAction.Invoke(param.LineItem);
var lineItem = param.LineItem;
var vm = ViewModelMapper.MapTo <LightLineItemDetailViewModel>(lineItem, param.CultureInfo);
if (vm.IsValid == null)
{
vm.IsValid = true;
}
ProductMainImage mainImage;
if (param.ImageDictionary.TryGetValue(Tuple.Create(lineItem.ProductId, lineItem.VariantId), out mainImage))
{
vm.ImageUrl = mainImage.ImageUrl;
vm.FallbackImageUrl = mainImage.FallbackImageUrl;
}
vm.ProductUrl = ProductUrlProvider.GetProductUrl(new GetProductUrlParam
{
CultureInfo = param.CultureInfo,
VariantId = lineItem.VariantId,
ProductId = lineItem.ProductId,
ProductName = lineItem.ProductSummary.DisplayName,
SKU = lineItem.Sku
});
return(vm);
}
public virtual LineItemDetailViewModel GetLineItemDetailViewModel(CreateLineItemDetailViewModelParam param)
{
if (param.PreMapAction != null)
{
param.PreMapAction.Invoke(param.LineItem);
}
var lineItem = param.LineItem;
var vm = ViewModelMapper.MapTo <LineItemDetailViewModel>(lineItem, param.CultureInfo);
if (vm.IsValid == null)
{
vm.IsValid = true;
}
vm.Rewards = RewardViewModelFactory.CreateViewModel(lineItem.Rewards, param.CultureInfo, RewardLevel.LineItem).ToList();
vm.IsOnSale = lineItem.CurrentPrice.HasValue && lineItem.DefaultPrice.HasValue &&
(int)(lineItem.CurrentPrice.Value * 100) < (int)(lineItem.DefaultPrice.Value * 100);
vm.IsPriceDiscounted = lineItem.DiscountAmount.GetValueOrDefault(0) > 0;
decimal lineItemsSavingSale = Math.Abs(decimal.Multiply(
decimal.Subtract(
lineItem.CurrentPrice.GetValueOrDefault(0),
lineItem.DefaultPrice.GetValueOrDefault(0)),
Convert.ToDecimal(lineItem.Quantity)));
decimal lineItemsSavingTotal = decimal.Add(lineItem.DiscountAmount.GetValueOrDefault(0), lineItemsSavingSale);
vm.SavingsTotal = lineItemsSavingTotal.Equals(0) ? string.Empty : LocalizationProvider.FormatPrice(lineItemsSavingTotal, CurrencyProvider.GetCurrency());
vm.KeyVariantAttributesList = GetKeyVariantAttributes(new GetKeyVariantAttributesParam {
KvaValues = lineItem.KvaValues,
KvaDisplayValues = lineItem.KvaDisplayValues
}).ToList();
if (param.ImageDictionary.TryGetValue((lineItem.ProductId, lineItem.VariantId), out ProductMainImage mainImage))
{
vm.ImageUrl = mainImage.ImageUrl;
vm.FallbackImageUrl = mainImage.FallbackImageUrl;
}
vm.ProductUrl = ProductUrlProvider.GetProductUrl(new GetProductUrlParam
{
CultureInfo = param.CultureInfo,
VariantId = lineItem.VariantId,
ProductId = lineItem.ProductId,
ProductName = lineItem.ProductSummary.DisplayName,
SKU = lineItem.Sku
});
vm.AdditionalFees = MapLineItemAdditionalFeeViewModel(lineItem, param.CultureInfo).ToList();
//Because the whole class is not async, we call a .Result here
_ = MapRecurringOrderFrequencies(vm, lineItem, param.CultureInfo).Result;
return(vm);
}
public string GetProductUrl(GetProductUrlParam parameters)
{
if (parameters is WebsiteGetProductUrlParam websitesParameters)
{
var provider = new ProductUrlProvider(PageService,
new Sitemap.WebsiteContextWrapper(websitesParameters.WebsiteId), SiteConfiguration);
return(provider.GetProductUrl(parameters));
}
return(null);
}
protected virtual string GetProductUrl(Uri baseUrl, CultureInfo cultureInfo, string productId, string variantId, string productName, string sku)
{
var param = new GetProductUrlParam
{
CultureInfo = cultureInfo,
ProductId = productId,
VariantId = variantId,
ProductName = productName,
SKU = sku
};
return(ProductUrlProvider.GetProductUrl(param));
}
private string BuildUrl(CultureInfo cultureInfo, string productName, string productId, string variantId, string sku)
{
var productUrl = ProductUrlProvider.GetProductUrl(new GetProductUrlParam
{
CultureInfo = cultureInfo,
ProductId = productId,
ProductName = productName,
VariantId = variantId,
SKU = sku
});
return(productUrl);
}
protected virtual void MapProductSearchViewModelUrl(
ProductSearchViewModel productSearchVm,
string productVariantId,
CultureInfo cultureInfo, string baseUrl)
{
productSearchVm.Url = ProductUrlProvider.GetProductUrl(new GetProductUrlParam
{
CultureInfo = cultureInfo,
ProductId = productSearchVm.ProductId,
ProductName = productSearchVm.FullDisplayName,
VariantId = productVariantId,
BaseUrl = baseUrl,
SKU = productSearchVm.Sku
});
}
protected virtual ProductViewModel CreateViewModel(CreateProductDetailViewModelParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (param.Product == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.Product)), nameof(param));
}
if (param.ProductDefinition == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.ProductDefinition)), nameof(param));
}
if (param.ProductLookups == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.ProductLookups)), nameof(param));
}
if (param.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CultureInfo)), nameof(param));
}
if (string.IsNullOrEmpty(param.BaseUrl))
{
throw new ArgumentException(GetMessageOfNullEmpty(nameof(param.BaseUrl)), nameof(param));
}
var productDetailViewModel = ViewModelMapper.MapTo <ProductViewModel>(param.Product, param.CultureInfo);
InitializeProductImages(param.Product.Id, param.ProductDetailImages, param.CultureInfo, productDetailViewModel);
var productDisplayName = productDetailViewModel.DisplayName ?? string.Empty;
var allVariantsVm = GetVariantViewModels(
param.Product.Variants,
param.ProductDefinition.VariantProperties,
productDisplayName,
param.CultureInfo,
vvm => InitializeVariantImages(param.Product.Id, param.ProductDetailImages, param.CultureInfo, vvm),
vvm => InitializeVariantSpecificaton(param.Product, param.ProductDefinition, vvm)
).ToList();
productDetailViewModel.Variants = allVariantsVm;
var selectedVariantVm = GetSelectedVariantViewModel(param.VariantId, allVariantsVm);
MergeSelectedVariantVmToProductVm(selectedVariantVm, productDetailViewModel);
var selectedKvas = GetSelectedKvas(selectedVariantVm, param);
productDetailViewModel.Context["selectedKvas"] = selectedKvas;
//todo: create factory? the code to build variants is huge
// get all the key variant attributes possibilities. For instance, if the product has colors and size. This method
// will produce two collections (colors, sizes) and for each collection, it will contain all the possible values.
productDetailViewModel.KeyVariantAttributeItems = CreateKvaItems(new GenerateKvaItemsParam
{
ProductLookups = param.ProductLookups,
Product = param.Product,
SelectedKvas = selectedKvas,
ProductDefinition = param.ProductDefinition,
CultureInfo = param.CultureInfo,
ProductVariants = allVariantsVm
});
productDetailViewModel.Price = param.Product.ListPrice;
productDetailViewModel.ProductDetailUrl = ProductUrlProvider.GetProductUrl(new GetProductUrlParam
{
CultureInfo = param.CultureInfo,
ProductId = param.Product.Id,
VariantId = param.VariantId,
SKU = param.Product.Sku,
ProductName = productDisplayName
});
productDetailViewModel.CreateAccountUrl = MyAccountUrlProvider.GetCreateAccountUrl(new BaseUrlParameter
{
CultureInfo = param.CultureInfo,
ReturnUrl = productDetailViewModel.ProductDetailUrl
});
SetViewModelContext(productDetailViewModel, selectedVariantVm, allVariantsVm);
// When the product lookup is loaded, only the keys of the lookup are assigned to the product view model. This method
// compare the product view model bag item keys with the lookups name and assign the right localized lookup values to the view model.
AssignLookupValuesToProductPropertyBag(param.ProductDefinition, param.ProductLookups, param.CultureInfo, productDetailViewModel);
productDetailViewModel.Description = FixHtml(productDetailViewModel.Description);
productDetailViewModel.DefinitionName = param.ProductDefinition.Name;
if (ProductConfiguration.IsQuantityDisplayed &&
ProductConfiguration.MinQuantity > 0 &&
ProductConfiguration.MaxQuantity >= ProductConfiguration.MinQuantity)
{
productDetailViewModel.Quantity = new ProductQuantityViewModel
{
Min = ProductConfiguration.MinQuantity,
Max = ProductConfiguration.MaxQuantity,
Value = ProductConfiguration.MinQuantity
};
}
productDetailViewModel.Currency = param.Currency;
productDetailViewModel.Specifications = ProductSpecificationsViewService.GetProductSpecificationsViewModel(new GetProductSpecificationsParam
{
Product = param.Product,
ProductDefinition = param.ProductDefinition
});
return(productDetailViewModel);
}
public virtual async Task <RecurringOrderTemplateLineItemViewModel> MapToTemplateLineItemViewModel(MapToTemplateLineItemViewModelParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (param.RecurringOrderlineItem == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.RecurringOrderlineItem)), nameof(param));
}
if (param.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CultureInfo)), nameof(param));
}
if (param.BaseUrl == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.BaseUrl)), nameof(param));
}
if (param.RecurringScheduleUrl == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.RecurringScheduleUrl)), nameof(param));
}
var recrurringLineItem = param.RecurringOrderlineItem;
var vm = ViewModelMapper.MapTo <RecurringOrderTemplateLineItemViewModel>(recrurringLineItem, param.CultureInfo);
if (vm.IsValid == null)
{
vm.IsValid = true;
}
if (param.ImageDictionnary.TryGetValue(Tuple.Create(recrurringLineItem.ProductId, recrurringLineItem.VariantId), out ProductMainImage mainImage))
{
vm.ImageUrl = mainImage.ImageUrl;
vm.FallbackImageUrl = mainImage.FallbackImageUrl;
}
var getProductRequest = new Overture.ServiceModel.Requests.Products.GetProductRequest
{
ProductId = recrurringLineItem.ProductId,
ScopeId = recrurringLineItem.ScopeId,
CultureName = param.CultureInfo.Name,
IncludePriceLists = true,
IncludeRelationships = false,
IncludeVariants = true
};
var getProductResponse = await OvertureClient.SendAsync(getProductRequest).ConfigureAwait(false);
if (getProductResponse == null || (getProductResponse != null && recrurringLineItem.VariantId != string.Empty &&
recrurringLineItem.VariantId != null &&
getProductResponse.Variants.SingleOrDefault(v => v.Id == recrurringLineItem.VariantId) == null))
{
var deleteRecurringLineItem = new DeleteRecurringOrderLineItemsRequest
{
CustomerId = recrurringLineItem.CustomerId,
RecurringOrderLineItemIds = new List <Guid> {
recrurringLineItem.RecurringOrderLineItemId
},
ScopeId = recrurringLineItem.ScopeId
};
await OvertureClient.SendAsync(deleteRecurringLineItem);
return(await Task.FromResult <RecurringOrderTemplateLineItemViewModel>(null));
}
var variant = getProductResponse.Variants.SingleOrDefault(v => v.Id == recrurringLineItem.VariantId);
vm.FormattedNextOccurence = vm.NextOccurence == DateTime.MinValue
? string.Empty
: string.Format(param.CultureInfo, "{0:D}", vm.NextOccurence);
vm.NextOccurenceValue = vm.NextOccurence == DateTime.MinValue
? string.Empty
: vm.NextOccurence.ToString("yyyy/MM/dd", CultureInfo.InvariantCulture);
vm.Id = recrurringLineItem.RecurringOrderLineItemId;
vm.ProductSummary = new RecurringProductSummaryViewModel
{
DisplayName = ProductHelper.GetProductOrVariantDisplayName(getProductResponse, variant, param.CultureInfo)
};
var productsPricesVm = await ProductPriceViewService.CalculatePricesAsync(new GetProductsPriceParam
{
CultureInfo = param.CultureInfo,
Scope = recrurringLineItem.ScopeId,
ProductIds = new List <string>()
{
recrurringLineItem.ProductId
}
});
var productPriceVm = productsPricesVm.ProductPrices.SingleOrDefault(p => p.ProductId == recrurringLineItem.ProductId);
if (productPriceVm != null)
{
var variantPriceVm = productPriceVm.VariantPrices.SingleOrDefault(v => v.VariantId == recrurringLineItem.VariantId);
if (variantPriceVm != null)
{
vm.DefaultListPrice = variantPriceVm.DefaultListPrice;
vm.ListPrice = variantPriceVm.ListPrice;
}
else
{
vm.DefaultListPrice = productPriceVm.DefaultListPrice;
vm.ListPrice = productPriceVm.ListPrice;
}
}
vm.IsOnSale = string.CompareOrdinal(vm.DefaultListPrice, vm.ListPrice) != 0;
var conv = decimal.TryParse(vm.ListPrice, NumberStyles.Currency, param.CultureInfo.NumberFormat, out decimal price);
if (conv)
{
vm.TotalWithoutDiscount = LocalizationProvider.FormatPrice((decimal)vm.Quantity * price, param.CultureInfo);
vm.Total = LocalizationProvider.FormatPrice((decimal)vm.Quantity * price, param.CultureInfo);
}
//Adding brand display name
var brandLookup = await OvertureClient.SendAsync(new GetProductLookupRequest { LookupName = "Brand" });
var brandId = getProductResponse.Brand;
if (brandId != null)
{
string brandValue = Convert.ToString(brandId);
vm.ProductSummary.Brand = brandLookup?.GetDisplayName(brandValue, param.CultureInfo.Name) ?? brandId;
}
var list = await ProductHelper.GetKeyVariantAttributes(getProductResponse, variant, param.CultureInfo, OvertureClient);
if (list != null && list.Count > 0)
{
vm.KeyVariantAttributesList = list.ToList();
}
vm.ShippingMethodName = recrurringLineItem.FulfillmentMethodName;
vm.ProductUrl = ProductUrlProvider.GetProductUrl(new GetProductUrlParam
{
CultureInfo = param.CultureInfo,
VariantId = recrurringLineItem.VariantId,
ProductId = recrurringLineItem.ProductId,
ProductName = vm.ProductSummary.DisplayName,
SKU = recrurringLineItem.Sku
});
var recurringScheduleEditUrl = RecurringScheduleUrlProvider.GetRecurringScheduleDetailsUrl(new GetRecurringScheduleDetailsUrlParam
{
CultureInfo = param.CultureInfo,
RecurringScheduleId = vm.Id.ToString()
});
vm.EditUrl = recurringScheduleEditUrl;
vm.ScheduleUrl = param.RecurringScheduleUrl;
var program = await RecurringOrderRepository.GetRecurringOrderProgram(recrurringLineItem.ScopeId, recrurringLineItem.RecurringOrderProgramName);
var programViewModel = RecurringOrderProgramViewModelFactory.CreateRecurringOrderProgramViewModel(program, param.CultureInfo);
vm.RecurringOrderProgramFrequencies = programViewModel?.Frequencies;
return(vm);
}
