public KachingProduct ConvertProduct(Product subject)
{
var product = new KachingProduct();
AddBasicProperties(subject, product);
AddAttributes(subject, product);
AddVariants(subject, product);
AddTags(subject, product);
return(product);
}
private void AddAttributes(Product subject, KachingProduct product)
{
if (subject.ProductProperties.Count > 0)
{
var attributes = new Dictionary <string, string>();
foreach (var prop in subject.ProductProperties)
{
var value = prop.Value;
var name = prop.ProductDefinitionField.Name;
attributes[name] = value;
}
product.Attributes = attributes;
}
}
private void AddBasicProperties(Product subject, KachingProduct product)
{
product.Name = Localizer.GetLocalizedName(new LocalizableProduct(subject));
product.Description = Localizer.GetLocalizedName(new LocalizableProductLongDescription(subject));
if (subject.ProductPrices.Count > 0)
{
product.RetailPrice = GetMarketPrice(subject.ProductPrices);
}
product.Id = subject.Guid.ToString();
if (!string.IsNullOrEmpty(subject.PrimaryImageMediaId))
{
var imageUrl = ObjectFactory.Instance.Resolve <UCommerce.Content.IImageService>().GetImage(subject.PrimaryImageMediaId).Url;
if (!string.IsNullOrEmpty(imageUrl))
{
product.ImageUrl = DomainName() + imageUrl;
}
}
}
private void AddVariants(Product subject, KachingProduct product)
{
var attributePropertyMap = new Dictionary <string, ProductDefinitionField>();
var list = new List <Variant>();
foreach (var v in subject.Variants)
{
var variant = new Variant();
AddBasicVariantProperties(v, variant);
AddVariantAttributes(attributePropertyMap, v, variant);
list.Add(variant);
}
if (list.Count > 0)
{
product.Variants = list.ToArray();
AddDimensions(product, attributePropertyMap, list);
}
}
private void AddTags(Product subject, KachingProduct product)
{
var tags = new HashSet <string>();
// Just as a convenience, always add a 'ucommerce' tag to allow for easy identification of
// products from Ucommerce.
tags.Add("ucommerce");
foreach (var category in subject.GetCategories())
{
tags.Add(category.Name);
var categoryIteration = category;
while (categoryIteration.ParentCategory != null)
{
categoryIteration = categoryIteration.ParentCategory;
tags.Add(categoryIteration.Name);
}
}
product.Tags = tags;
}
public PipelineExecutionResult Execute(Product subject)
{
var config = KachingConfiguration.Get();
var url = config.ProductsIntegrationURL;
if (!url.StartsWith("https://", StringComparison.Ordinal))
{
return(PipelineExecutionResult.Success);
}
// In case a product is initially being created, it will not yet have a
// category configured. In this case delay the synchronization slightly
// in order to let the database save the product<->category relationship.
Func <PipelineExecutionResult> synchronize = () =>
{
var converter = new ProductConverter(logging);
var product = converter.ConvertProduct(subject);
KachingProduct[] products = new KachingProduct[1];
products[0] = product;
var metadata = converter.GetMetadata();
return(Synchronizer.Post(new ProductsRequest(products, metadata), url));
};
if (subject.GetCategories().Count == 0)
{
Task.Delay(2000).ContinueWith((task) =>
{
synchronize();
});
return(PipelineExecutionResult.Success);
}
return(synchronize());
}
private void AddDimensions(KachingProduct product, Dictionary <string, ProductDefinitionField> attributePropertyMap, List <Variant> list)
{
foreach (var attribute in attributePropertyMap.Keys)
{
var flag = false;
var alreadyUsed = new HashSet <string>();
foreach (var variant in list)
{
if (variant.Attributes == null || variant.Attributes[attribute] == null)
{
flag = true;
break;
}
var value = variant.Attributes[attribute];
if (alreadyUsed.Contains(value))
{
flag = true;
break;
}
alreadyUsed.Add(value);
}
if (flag)
{
continue;
}
else
{
// attribute uniquely identifies each variant - use it for a dimension
var propertyDefinition = attributePropertyMap[attribute];
var dimension = new Dimension();
dimension.Id = propertyDefinition.Name;
dimension.Name = Localizer.GetLocalizedName(new LocalizableProductDefinitionField(propertyDefinition));
dimension.Values = new List <DimensionValue>();
foreach (var property in propertyDefinition.DataType.DataTypeEnums)
{
var value = new DimensionValue();
value.Id = property.Name;
value.Name = Localizer.GetLocalizedName(new LocalizableDataTypeEnum(property));
dimension.Values.Add(value);
}
if (dimension.Values.Count == 0)
{
// No enums defined - show values directly instead
var allValues = new HashSet <string>();
foreach (var variant in product.Variants)
{
allValues.Add(variant.Attributes[attribute]);
}
foreach (var valueString in allValues.OrderBy(a => a))
{
var value = new DimensionValue();
value.Id = valueString;
value.Name = new L10nString(valueString);
dimension.Values.Add(value);
}
}
product.Dimensions = new List <Dimension>();
product.Dimensions.Add(dimension);
foreach (var variant in product.Variants)
{
variant.DimensionValues = new Dictionary <string, string>();
variant.DimensionValues[dimension.Id] = variant.Attributes[attribute];
}
break;
}
}
}
