public new void Initialize(ProductEntity product, bool initializeAsMock = false)
{
base.Initialize(product, initializeAsMock);
List <VariantEntity> variants = new List <VariantEntity>();
if (product.Item.HasChildren)
{
foreach (Item item in product.Item.Children)
{
VariantEntity model = this.ModelProvider.GetModel <VariantEntity>();
model.Initialize(item);
variants.Add(model);
}
}
else
{
// no variants - product is purchasable as self
IsPurchasable = true;
}
if (variants.Count == 1)
{
// max 1 variant, so this product is purchasable through its only variant
VariantId = variants.Select(a => a.VariantId).FirstOrDefault();
IsPurchasable = true;
}
else
{
VariantId = null;
IsPurchasable = false;
}
}
protected virtual CatalogItemVariantsRenderingModel GetCatalogItemVariantsRenderingModel(
IVisitorContext visitorContext,
Item productItem)
{
Assert.ArgumentNotNull(visitorContext, nameof(visitorContext));
//Important: make sure to use the CurrentCatalogItemVariantsRenderingModelKeyName constant here
if (SiteContext.Items[CurrentCatalogItemVariantsRenderingModelKeyName] != null)
{
return((CatalogItemVariantsRenderingModel)SiteContext.Items[CurrentCatalogItemVariantsRenderingModelKeyName]);
}
CommerceStorefront currentStorefront = StorefrontContext.CurrentStorefront;
List <VariantEntity> variantEntityList = new List <VariantEntity>();
if (productItem != null && productItem.HasChildren)
{
foreach (Item child in productItem.Children)
{
VariantEntity model = ModelProvider.GetModel <VariantEntity>();
model.Initialize(child);
variantEntityList.Add(model);
}
}
ProductEntity productEntity = ModelProvider.GetModel <ProductEntity>();
productEntity.Initialize(currentStorefront, productItem, variantEntityList);
CatalogItemVariantsRenderingModel catalogModel = ModelProvider.GetModel <CatalogItemVariantsRenderingModel>();
Init(catalogModel);
if (SiteContext.UrlContainsCategory)
{
catalogModel.ParentCategoryId = CatalogUrlManager.ExtractCategoryNameFromCurrentUrl();
Item category = SearchManager.GetCategory(catalogModel.ParentCategoryId, currentStorefront.Catalog);
if (category != null)
{
catalogModel.ParentCategoryName = category.DisplayName;
}
}
if (string.Equals(catalogModel.ProductId, currentStorefront.GiftCardProductId, StringComparison.Ordinal))
{
catalogModel.GiftCardAmountOptions = GetGiftCardAmountOptions(visitorContext, currentStorefront, productEntity);
}
else
{
CatalogManager.GetProductPrice(currentStorefront, visitorContext, productEntity, null);
catalogModel.CustomerAverageRating = CatalogManager.GetProductRating(productItem, null);
}
catalogModel.Initialize(productEntity, false);
SiteContext.Items["CurrentCatalogItemVariantsRenderingModel"] = catalogModel;
return(catalogModel);
}
protected virtual List <VariantEntity> GetProductVariants(Item productItem)
{
Assert.ArgumentNotNull(productItem, nameof(productItem));
var variantEntityList = new List <VariantEntity>();
var personalizationId = _personalizationCache.ContainsKey("PersonalizationId") ? _personalizationCache.GetValue("PersonalizationId").ToString() : string.Empty;
var childList = productItem.Children.Where(child => personalizationId.Equals(child["PersonalizationId"], System.StringComparison.OrdinalIgnoreCase));
if (!childList.Any())
{
childList = productItem.Children.Where(child => string.IsNullOrEmpty(child["PersonalizationId"]));
}
foreach (Item variantItem in childList)
{
VariantEntity model = this.ModelProvider.GetModel <VariantEntity>();
model.Initialize(variantItem);
variantEntityList.Add(model);
}
return(variantEntityList);
}
/// <summary>
/// Method To Insert Variant Into DB from UI
/// </summary>
/// <param name="_variant"></param>
/// <returns></returns>
public bool AddVariant(VariantEntity _variant)
{
bool isSuccess = false;
using (var scope = new TransactionScope())
{
//var config = new MapperConfiguration(cfg => { cfg.CreateMap<VariantEntity, Variant>(); });
//IMapper mapper = config.CreateMapper();
//var subProducts = mapper.Map<VariantEntity, Variant>(_variant);
var variant = Mapper.DynamicMap <VariantEntity, Variant>(_variant);
_unitOfWork.VariantRepository.Insert(variant);
_unitOfWork.Save();
scope.Complete();
isSuccess = true;
}
return(isSuccess);
}
protected virtual ProductSummaryViewModel CatalogItemRenderingModel(IVisitorContext visitorContext, Item productItem)
{
Assert.ArgumentNotNull(visitorContext, "visitorContext");
var currentStorefront = StorefrontContext.CurrentStorefront;
var variantEntityList = new List <VariantEntity>();
if (productItem != null && productItem.HasChildren)
{
foreach (Item variant in productItem.Children)
{
VariantEntity model = ModelProvider.GetModel <VariantEntity>();
model.Initialize(variant);
variantEntityList.Add(model);
}
}
ProductEntity productEntity = ModelProvider.GetModel <ProductEntity>();
productEntity.Initialize(currentStorefront, productItem, variantEntityList);
var renderingModel = ModelProvider.GetModel <ProductSummaryViewModel>();
var products = new List <ProductEntity> {
productEntity
};
InventoryManager.GetProductsStockStatus(currentStorefront, products, currentStorefront.UseIndexFileForProductStatusInLists);
CatalogManager.GetProductBulkPrices(currentStorefront, visitorContext, products);
if (productEntity.ProductId == currentStorefront.GiftCardProductId)
{
renderingModel.GiftCardAmountOptions = GetGiftCardAmountOptions(visitorContext, currentStorefront, productEntity);
}
else
{
renderingModel.CustomerAverageRating = CatalogManager.GetProductRating(productItem);
}
renderingModel.Initialize(productEntity, false);
return(renderingModel);
}
public bool AddVariant([FromBody] VariantEntity _variantEntity)
{
return(_productServices.AddVariant(_variantEntity));
}
public virtual CatalogItemRenderingModel XcGetCatalogItemRenderingModel(IVisitorContext visitorContext, Item productItem)
{
Assert.ArgumentNotNull(visitorContext, nameof(visitorContext));
CommerceStorefront currentStorefront = this.StorefrontContext.CurrentStorefront;
List <VariantEntity> variantEntityList = new List <VariantEntity>();
if (productItem != null && productItem.HasChildren)
{
var childList = productItem.Children.Where(child =>
{
var variantPersonalizationId = child["PersonalizationId"];
var liveDate = child["LiveDate"];
var expiryDate = child["ExpiryDate"];
if (this.PersonalizationId.Equals(child["PersonalizationId"], System.StringComparison.OrdinalIgnoreCase))
{
if (!string.IsNullOrEmpty(liveDate))
{
var parseSuccess = DateTimeOffset.TryParseExact(liveDate, "yyyyMMddTHHmmss", null, DateTimeStyles.None, out var variantLiveDate);
if (parseSuccess && variantLiveDate > DateTimeOffset.Now)
{
return(false);
}
}
if (!string.IsNullOrEmpty(expiryDate))
{
var parseSuccess = DateTimeOffset.TryParseExact(expiryDate, "yyyyMMddTHHmmss", null, DateTimeStyles.None, out var variantExpiryDate);
if (parseSuccess && variantExpiryDate <= DateTimeOffset.Now)
{
return(false);
}
}
return(true);
}
return(false);
});
if (!childList.Any())
{
childList = productItem.Children.Where(child => string.IsNullOrEmpty(child["PersonalizationId"]));
}
foreach (Item variantItem in childList)
{
VariantEntity model = this.ModelProvider.GetModel <VariantEntity>();
model.Initialize(variantItem);
variantEntityList.Add(model);
}
}
ProductEntity model1 = this.ModelProvider.GetModel <ProductEntity>();
model1.Initialize(currentStorefront, productItem, variantEntityList);
CatalogItemRenderingModel model2 = this.ModelProvider.GetModel <CatalogItemRenderingModel>();
this.Init(model2);
if (this.SiteContext.UrlContainsCategory)
{
model2.ParentCategoryId = this.CatalogUrlManager.ExtractCategoryNameFromCurrentUrl();
Item category = this.SearchManager.GetCategory(model2.ParentCategoryId, currentStorefront.Catalog);
if (category != null)
{
model2.ParentCategoryName = category.DisplayName;
}
}
if (model2.ProductId == currentStorefront.GiftCardProductId)
{
model2.GiftCardAmountOptions = this.GetGiftCardAmountOptions(visitorContext, currentStorefront, model1);
}
else
{
this.CatalogManager.GetProductPrice(currentStorefront, visitorContext, model1, null);
model2.CustomerAverageRating = this.CatalogManager.GetProductRating(productItem, null);
}
model2.Initialize(model1, false);
//this.SiteContext.Items["CurrentCatalogItemRenderingModel"] = model2;
if (model2.CatalogItem.HasChildren)
{
var childList = model2.CatalogItem.Children.Where(child => this.PersonalizationId.Equals(child["PersonalizationId"], System.StringComparison.OrdinalIgnoreCase));
if (!childList.Any())
{
childList = model2.CatalogItem.Children.Where(child => string.IsNullOrEmpty(child["PersonalizationId"]));
}
foreach (Item child in childList)
{
MultilistField field = child.Fields["Images"];
if (field != null)
{
model2.Images.Clear();
foreach (ID targetId in field.TargetIDs)
{
model2.Images.Add(child.Database.GetItem(targetId));
}
return(model2);
}
}
}
return(model2);
}