private void AddProductDefinitionFieldIfDoesntExist(ProductDefinition definition, string name, string typeName,
bool displayOnWebsite, bool variantProperty, bool promotoToFacet, string displayName)
{
if (definition.GetDefinitionFields().Any(f => f.Name == name))
{
return;
}
var field = ProductDefinitionField.SingleOrDefault(f =>
f.Name == name && f.ProductDefinition.ProductDefinitionId ==
definition.ProductDefinitionId) ??
new ProductDefinitionFieldFactory().NewWithDefaults(name);
field.Name = name;
field.DataType = DataType.SingleOrDefault(d => d.TypeName == typeName);
field.Deleted = false;
field.Multilingual = false;
field.DisplayOnSite = displayOnWebsite;
field.IsVariantProperty = variantProperty;
field.RenderInEditor = true;
field.Facet = promotoToFacet;
definition.AddProductDefinitionField(field);
definition.Save();
}
private void AddCustomDefinitionFields(ProductDefinition definition, ProductTypeViewModel sfProductType)
{
var dataType = _session.Query <DataType>().FirstOrDefault(x => x.TypeName == "ShortText");
if (sfProductType.ProductAttributes == null)
{
Log.Info($"No product attributes found to associate to product definition '{sfProductType.Title}'");
return;
}
foreach (var attribute in sfProductType.ProductAttributes)
{
Log.Info(
$"Adding attribute/definition field '{attribute.Title}' to product definition '{definition.Name}'");
var definitionField = new ProductDefinitionField()
{
Multilingual = true,
DisplayOnSite = attribute.Visible,
Deleted = false,
RenderInEditor = true,
IsVariantProperty = true,
SortOrder = 0,
Name = attribute.Title.Trim(),
DataType = dataType
};
definition.AddProductDefinitionField(definitionField);
}
}
private void CreateDynamicItemField(TemplateBuilder builder, ProductDefinitionField definitionField, int sortOrder, ID parentId)
{
ID id = definitionField.SitecoreTemplateFieldForVariant(parentId);
TemplateFieldHelper.CreateField(builder, definitionField, sortOrder, id);
_productDefinitionFieldIdToFieldIdMap[definitionField.ProductDefinitionFieldId] = id;
}
private void AddProductDefinitionFieldIfDoesntExist(ProductDefinition definition, string name, string typeName, bool displayOnWebsite, bool variantProperty, bool promotoToFacet, string displayName)
{
if (definition.GetDefinitionFields().Any(f => f.Name == name))
{
return;
}
var field = ProductDefinitionField.SingleOrDefault(f => f.Name == name && f.ProductDefinition.ProductDefinitionId == definition.ProductDefinitionId) ?? new ProductDefinitionFieldFactory().NewWithDefaults(name);
field.Name = name;
field.DataType = DataType.SingleOrDefault(d => d.TypeName == typeName);
field.Deleted = false;
field.Multilingual = false;
field.DisplayOnSite = displayOnWebsite;
field.IsVariantProperty = variantProperty;
field.RenderInEditor = true;
field.Facet = promotoToFacet;
//Helpers.DoForEachCulture(language =>
// {
// if (field.GetDescription(language) == null)
// field.AddProductDefinitionFieldDescription(new ProductDefinitionFieldDescription { CultureCode = language, DisplayName = displayName, Description = displayName });
// });
definition.AddProductDefinitionField(field);
definition.Save();
}
public static void CreateField(TemplateBuilder builder, ProductDefinitionField definitionField,
int sortOrder, ID id)
{
if (definitionField.DataType == null)
{
return; // Skip creation, if there is no datatype.
}
var displaynamesByCultureCodes = new List <KeyValuePair <string, string> >();
var descriptions = definitionField.ProductDefinitionFieldDescriptions;
foreach (var description in descriptions.Where(x => x.ProductDefinitionField.RenderInEditor))
{
var cultureCode = description.CultureCode;
if (displaynamesByCultureCodes.Any(x => x.Key == description.CultureCode))
{
continue;
}
var displayName = description.DisplayName;
displaynamesByCultureCodes.Add(new KeyValuePair <string, string>(cultureCode, displayName));
}
builder.CreateDynamicItemFieldByDataType(id, definitionField.DataType, sortOrder, displaynamesByCultureCodes,
definitionField.Name);
}
private ProductDefinitionField CreateFiield(PropertyInfo propertyInfo, ProductDefinition definition)
{
var fieldAttribute = propertyInfo.AssertGetAttribute<ProductFieldAttribute>();
var fieldName = fieldAttribute.Name.IsNotEmpty()
? fieldAttribute.Name
: propertyInfo.Name;
var field = definition.ProductDefinitionFields
.EmptyIfNull()
.SingleOrDefault(x => x.Name == fieldName);
if (field == null)
{
var dataType = _session.QueryOver<DataType>()
.Where(x => x.TypeName == fieldAttribute.DataType)
.SingleOrDefault();
field = new ProductDefinitionField
{
Name = fieldName,
DataType = dataType
};
definition.AddProductDefinitionField(field);
}
field.DisplayOnSite = fieldAttribute.DisplayOnSite;
field.Multilingual = fieldAttribute.Multilingual;
field.RenderInEditor = fieldAttribute.RenderInEditor;
field.Searchable = fieldAttribute.Searchable;
field.SortOrder = fieldAttribute.SortOrder;
field.Facet = fieldAttribute.Facet;
field.IsVariantProperty = fieldAttribute.IsVariantProperty;
return field;
}
public static ID SitecoreTemplateField(this ProductDefinitionField @this, ID parentId)
{
var id = new ID(@this.Guid);
DynamicFieldIds.Add(id);
return(id);
}
public static ID SitecoreTemplateFieldForVariant(this ProductDefinitionField @this, ID parentId)
{
// A field cannot be both a variant field and not be a variant field. Therefore there is no clash when using the guid as is.
var id = new ID(@this.Guid);
DynamicFieldIds.Add(id);
return(id);
}
private ProductDefinitionField GetProductDefinitionField(Product product, string name)
{
var field = ProductDefinitionField.SingleOrDefault(d => product.ProductDefinition.Name == d.ProductDefinition.Name && d.Name == name);
if (field == null)
{
throw new ArgumentOutOfRangeException("field", string.Format("No product definition field with the name \"{0}\" could be found. Please check you have installed the default settings.", name));
}
return(field);
}
private void AddProductProperty(Product product, string name, string value)
{
var field = new ProductDefinitionField();
field.Name = name;
field.Multilingual = false;
var productProperty = new ProductProperty();
productProperty.Value = value;
productProperty.ProductDefinitionField = field;
product.ProductProperties.Add(productProperty);
}
private ProductDefinitionField CreateProductDefinitionField(string name, DataTypeDefinition definition)
{
var productDefinitionField = new ProductDefinitionField()
{
DataType = _dataTypeRepository.Select().FirstOrDefault(x => x.DefinitionName == definition.Name),
Name = name,
RenderInEditor = true,
};
var descriptions = CreateDefinitionFieldsDescriptions(name);
descriptions.ForEach(productDefinitionField.AddProductDefinitionFieldDescription);
return(productDefinitionField);
}
private void AddProductProperties(Product product, ProductViewModel sfProduct)
{
if (sfProduct.Item.CustomFields.Count == 0)
{
return;
}
// All properties are currently imported as ShortText properties
var dataType = _session.Query <DataType>().FirstOrDefault(x => x.TypeName == "ShortText");
foreach (var customProperty in sfProduct.Item.CustomFields)
{
if (customProperty.Key == "Department")
{
continue;
}
var property =
product.ProductDefinition.ProductDefinitionFields.FirstOrDefault(x => x.Name == customProperty.Key);
if (property == null)
{
property = new ProductDefinitionField
{
DisplayOnSite = true,
Deleted = false,
RenderInEditor = true,
IsVariantProperty = false,
SortOrder = 0,
Name = customProperty.Key,
DataType = dataType,
Multilingual = true
};
product.ProductDefinition.AddProductDefinitionField(property);
}
var propertyValue = GetPropertyValue(customProperty);
var currentProductProperty = new ProductProperty
{
Value = propertyValue,
ProductDefinitionField = property,
Product = product
};
product.AddProductProperty(currentProductProperty);
}
}
public void AddInventoryDefinitionField(ProductDefinition definition)
{
var dataType = _session.Query <DataType>().FirstOrDefault(x => x.TypeName == "Number");
var definitionField = new ProductDefinitionField()
{
Multilingual = false,
DisplayOnSite = true,
Deleted = false,
RenderInEditor = true,
IsVariantProperty = true,
SortOrder = 0,
Name = "InventoryOnHand",
DataType = dataType
};
definition.AddProductDefinitionField(definitionField);
}
public void RemoveDefinitionFields(ProductDefinition product, params string[] names)
{
foreach (var name in names)
{
try
{
ProductDefinitionField toBeRemoved = _productDefinitionFields.Value.SingleOrDefault(x => x.Name == name && x.ProductDefinition == product && !x.Deleted);
if (toBeRemoved != null)
{
product.ProductDefinitionFields.Remove(toBeRemoved);
}
}
catch (Exception ex)
{
string message = string.Format("'{0}' product definition field doesn't exist.", name);
throw new InvalidOperationException(message, ex);
}
}
}
public ProductDefinitionField AddDefinitionField(string name, ProductDefinition product, DataType type, bool multilingual = false)
{
ProductDefinitionField field = _productDefinitionFields.Value.SingleOrDefault(x => x.Name == name && x.ProductDefinition == product);
if (field == null)
{
field = new ProductDefinitionField();
}
field.DataType = type;
field.DisplayOnSite = true;
field.Name = name;
field.ProductDefinition = product;
field.RenderInEditor = true;
field.Multilingual = multilingual;
field.Deleted = false;
product.ProductDefinitionFields.Add(field);
return(field);
}
private static void AddMultilingualDescriptions(PropertyInfo propertyInfo, ProductDefinitionField field)
{
foreach (var description in propertyInfo.GetCustomAttributes<LanguageAttribute>())
{
var fieldDescription = field.ProductDefinitionFieldDescriptions.
EmptyIfNull()
.SingleOrDefault(x => x.CultureCode == description.Language);
if (fieldDescription == null)
{
fieldDescription = new ProductDefinitionFieldDescription
{
CultureCode = description.Language
};
field.AddProductDefinitionFieldDescription(fieldDescription);
}
fieldDescription.DisplayName = description.DisplayName;
fieldDescription.Description = description.Description;
}
}
private void AddProductDescriptionProperty(Product product, string name, string value, string cultureCode)
{
var field = new ProductDefinitionField();
field.Name = name;
field.Multilingual = true;
var productDescription = product.ProductDescriptions.SingleOrDefault(x => x.CultureCode == cultureCode);
if (productDescription == null)
{
throw new NullReferenceException(
"productDescription should not be null since its parsed before 'ProductDescriptionProperties'");
}
var productProperty = new ProductDescriptionProperty
{
Value = value,
ProductDefinitionField = field
};
productDescription.ProductDescriptionProperties.Add(productProperty);
}
public ProductDefinitionField AddDefinitionField(string name, ProductDefinition product, DataType type, bool multilingual = false)
{
ProductDefinitionField field = _productDefinitionFields.Value.SingleOrDefault(x => x.Name == name && x.ProductDefinition == product);
if (field == null)
{
field = new ProductDefinitionField();
}
field.DataType = type;
field.DisplayOnSite = true;
field.Name = name;
field.ProductDefinition = product;
field.RenderInEditor = true;
field.Multilingual = multilingual;
field.Deleted = false;
product.ProductDefinitionFields.Add(field);
return field;
}
/// <summary>
/// True if there is a productDefintionField with same Name and DateType which isn't deleted.
/// </summary>
/// <param name="existingShoeDefinition"></param>
/// <param name="productDefinitionField"></param>
/// <returns></returns>
private static bool ProductDefinitionfieldExist(UCommerce.EntitiesV2.ProductDefinition existingShoeDefinition, ProductDefinitionField productDefinitionField)
{
return(existingShoeDefinition.ProductDefinitionFields.Any(x => x.Name == productDefinitionField.Name && x.DataType.DataTypeId == productDefinitionField.DataType.DataTypeId && !x.Deleted));
}
/// <summary>
/// Updates the name on the new ProductDefinitionField if a existing productDefintionField has the same name.
/// </summary>
/// <param name="existingShoeDefinition"></param>
/// <param name="productDefinitionField"></param>
private void EnsureFieldNameIsUnique(UCommerce.EntitiesV2.ProductDefinition existingShoeDefinition, ProductDefinitionField productDefinitionField)
{
if (existingShoeDefinition.ProductDefinitionFields.Any(x => x.Name == productDefinitionField.Name && !x.Deleted))
{
productDefinitionField.Name = string.Format("{0}_{1}", productDefinitionField.Name,
productDefinitionField.DataType.DefinitionName);
}
}
public LocalizableProductDefinitionField(ProductDefinitionField field)
{
this.field = field;
}
