private void AddDynamicPropertyReadingMap(IList <DynamicProperty> dynamicProperties, Dictionary <string, IList <DynamicPropertyDictionaryItem> > dynamicPropertyDictionaryItems)
{
var currentColumnIndex = MemberMaps.Count;
var dynamicPropertiesPropertyInfo = ClassType.GetProperty(nameof(IHasDynamicProperties.DynamicProperties));
var dynamicPropertyReadingMap = MemberMap.CreateGeneric(ClassType, dynamicPropertiesPropertyInfo);
dynamicPropertyReadingMap.Data.ReadingConvertExpression =
(Expression <Func <IReaderRow, object> >)(row => dynamicProperties
.Select(dynamicProperty =>
!string.IsNullOrEmpty(row.GetField <string>(dynamicProperty.Name))
? new DynamicObjectProperty
{
Id = dynamicProperty.Id,
Name = dynamicProperty.Name,
DisplayNames = dynamicProperty.DisplayNames,
DisplayOrder = dynamicProperty.DisplayOrder,
Description = dynamicProperty.Description,
IsArray = dynamicProperty.IsArray,
IsDictionary = dynamicProperty.IsDictionary,
IsMultilingual = dynamicProperty.IsMultilingual,
IsRequired = dynamicProperty.IsRequired,
ValueType = dynamicProperty.ValueType,
Values = ToDynamicPropertyValues(dynamicProperty, dynamicPropertyDictionaryItems, row.GetField <string>(dynamicProperty.Name))
}
: null)
.Where(x => x != null)
.ToList());
dynamicPropertyReadingMap.UsingExpression <ICollection <DynamicObjectProperty> >(null, null);
dynamicPropertyReadingMap.Ignore(true);
dynamicPropertyReadingMap.Data.IsOptional = true;
dynamicPropertyReadingMap.Data.Index = currentColumnIndex + 1;
MemberMaps.Add(dynamicPropertyReadingMap);
}
public void Initialize(IEnumerable <string> customAttributes)
{
var classType = typeof(Operation);
var customAttributesPropertyInfo = classType.GetPropertyEx("Attributes");
foreach (var customAttribute in customAttributes)
{
var csvPropertyMap = MemberMap.CreateGeneric(classType, customAttributesPropertyInfo);
csvPropertyMap.Name(customAttribute).TypeConverter(new CustomAttributesTypeConverter(customAttribute));
csvPropertyMap.Data.Index = GetMaxIndex() + 1;
MemberMaps.Add(csvPropertyMap);
}
}
public ImportedEventNameClassMap()
{
// allow each field to be serialized by PascalCase, snake_case, or camelCase
foreach (var property in Properties)
{
var map = MemberMap.CreateGeneric(typeof(ImportedEvent), property);
var pascalName = property.Name;
var snakeName = pascalName.ToSnakeCase();
var camelName = pascalName.ToCamelCase();
map.Name(pascalName, snakeName, camelName);
this.MemberMaps.Add(map);
}
}
private void AddDynamicPropertyColumnDefinitionAndWritingMap(IList <DynamicProperty> dynamicProperties)
{
var currentColumnIndex = MemberMaps.Count;
var dynamicPropertiesPropertyInfo = ClassType.GetProperty(nameof(IHasDynamicProperties.DynamicProperties));
// Exporting multiple csv fields from the same property (which is a collection)
foreach (var dynamicProperty in dynamicProperties)
{
// create CsvPropertyMap manually, because this.Map(x =>...) does not allow
// to export multiple entries for the same property
var dynamicPropertyColumnDefinitionAndWriteMap = MemberMap.CreateGeneric(ClassType, dynamicPropertiesPropertyInfo);
dynamicPropertyColumnDefinitionAndWriteMap.Name(dynamicProperty.Name);
dynamicPropertyColumnDefinitionAndWriteMap.Data.IsOptional = true;
dynamicPropertyColumnDefinitionAndWriteMap.Data.Index = currentColumnIndex++;
// create custom converter instance which will get the required record from the collection
dynamicPropertyColumnDefinitionAndWriteMap.UsingExpression <ICollection <DynamicObjectProperty> >(null, dynamicObjectProperties =>
{
var dynamicObjectProperty = dynamicObjectProperties.FirstOrDefault(x => x.Name == dynamicProperty.Name && x.Values.Any());
var dynamicObjectPropertyValues = Array.Empty <string>();
if (dynamicObjectProperty != null)
{
if (dynamicObjectProperty.IsDictionary)
{
dynamicObjectPropertyValues = dynamicObjectProperty.Values?
.Where(x => x.Value != null)
.Select(x => x.Value.ToString())
.Distinct()
.ToArray();
}
else
{
dynamicObjectPropertyValues = dynamicObjectProperty.Values?
.Where(x => x.Value != null)
.Select(x => x.Value.ToString())
.ToArray();
}
}
return(string.Join(", ", dynamicObjectPropertyValues));
});
MemberMaps.Add(dynamicPropertyColumnDefinitionAndWriteMap);
}
}
private static MemberMap CreateMemberMap(Type currentType, PropertyInfo propertyInfo, string columnName, ref int columnIndex)
{
var memberMap = MemberMap.CreateGeneric(currentType, propertyInfo);
memberMap.Data.TypeConverterOptions.CultureInfo = CultureInfo.InvariantCulture;
memberMap.Data.TypeConverterOptions.NumberStyle = NumberStyles.Any;
memberMap.Data.TypeConverterOptions.BooleanTrueValues.AddRange(new List <string>()
{
"yes", "true"
});
memberMap.Data.TypeConverterOptions.BooleanFalseValues.AddRange(new List <string>()
{
"false", "no"
});
memberMap.Data.Names.Add(columnName);
memberMap.Data.NameIndex = memberMap.Data.Names.Count - 1;
memberMap.Data.Index = ++columnIndex;
return(memberMap);
}
public CsvProductMap(CsvProductMappingConfiguration mappingCfg)
{
//Dynamical map scalar product fields use by manual mapping information
var index = 0;
foreach (var mappingItem in mappingCfg.PropertyMaps.Where(x => !string.IsNullOrEmpty(x.CsvColumnName) || !string.IsNullOrEmpty(x.CustomValue)))
{
var propertyInfo = typeof(CsvProduct).GetProperty(mappingItem.EntityColumnName);
if (propertyInfo != null)
{
var newMap = MemberMap.CreateGeneric(typeof(CsvProduct), propertyInfo);
newMap.Data.TypeConverterOptions.CultureInfo = CultureInfo.InvariantCulture;
newMap.Data.TypeConverterOptions.NumberStyle = NumberStyles.Any;
newMap.Data.TypeConverterOptions.BooleanTrueValues.AddRange(new List <string>()
{
"yes", "true"
});
newMap.Data.TypeConverterOptions.BooleanFalseValues.AddRange(new List <string>()
{
"false", "no"
});
newMap.Data.Index = ++index;
if (!string.IsNullOrEmpty(mappingItem.CsvColumnName))
{
//Map fields if mapping specified
newMap.Name(mappingItem.CsvColumnName);
}
//And default values if it specified
else if (mappingItem.CustomValue != null)
{
var typeConverter = TypeDescriptor.GetConverter(propertyInfo.PropertyType);
newMap.Data.ReadingConvertExpression = (Expression <Func <IReaderRow, object> >)(x => typeConverter.ConvertFromString(mappingItem.CustomValue));
newMap.Default(mappingItem.CustomValue);
}
MemberMaps.Add(newMap);
}
}
//Map properties
if (mappingCfg.PropertyCsvColumns != null && mappingCfg.PropertyCsvColumns.Any())
{
// Exporting multiple csv fields from the same property (which is a collection)
foreach (var propertyCsvColumn in mappingCfg.PropertyCsvColumns)
{
// create CsvPropertyMap manually, because this.Map(x =>...) does not allow
// to export multiple entries for the same property
var propertyValuesInfo = typeof(CsvProduct).GetProperty(nameof(CsvProduct.Properties));
var csvPropertyMap = MemberMap.CreateGeneric(typeof(CsvProduct), propertyValuesInfo);
csvPropertyMap.Name(propertyCsvColumn);
csvPropertyMap.Data.Index = ++index;
// create custom converter instance which will get the required record from the collection
csvPropertyMap.UsingExpression <ICollection <Property> >(null, properties =>
{
var property = properties.FirstOrDefault(x => x.Name == propertyCsvColumn && x.Values.Any());
var propertyValues = Array.Empty <string>();
if (property != null)
{
if (property.Dictionary)
{
propertyValues = property.Values
?.Where(x => !string.IsNullOrEmpty(x.Alias))
.Select(x => x.Alias)
.Distinct()
.ToArray();
}
else
{
propertyValues = property.Values
?.Where(x => x.Value != null || x.Alias != null)
.Select(x => x.Alias ?? x.Value.ToString())
.ToArray();
}
}
return(string.Join(mappingCfg.Delimiter, propertyValues));
});
MemberMaps.Add(csvPropertyMap);
}
var newPropInfo = typeof(CsvProduct).GetProperty(nameof(CsvProduct.Properties));
var newPropMap = MemberMap.CreateGeneric(typeof(CsvProduct), newPropInfo);
newPropMap.Data.ReadingConvertExpression =
(Expression <Func <IReaderRow, object> >)(x => mappingCfg.PropertyCsvColumns.Select(column =>
(Property) new CsvProperty
{
Name = column,
Values = new List <PropertyValue>()
{
new PropertyValue()
{
PropertyName = column,
Value = x.GetField <string>(column)
}
}
}).ToList());
newPropMap.UsingExpression <ICollection <PropertyValue> >(null, null);
newPropMap.Data.Index = ++index;
MemberMaps.Add(newPropMap);
newPropMap.Ignore(true);
}
//map line number
var lineNumMeber = Map(m => m.LineNumber).ConvertUsing(row => row.Context.RawRow);
lineNumMeber.Data.Index = ++index;
lineNumMeber.Ignore(true);
}
