public CsvProductMap(CsvProductMappingConfiguration mappingCfg) { //Dynamical map scalar product fields use by manual mapping information 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 = new CsvPropertyMap(propertyInfo); newMap.TypeConverterOption(CultureInfo.InvariantCulture); newMap.TypeConverterOption(NumberStyles.Any); newMap.TypeConverterOption(true, "yes", "true"); newMap.TypeConverterOption(false, "false", "no"); if (!string.IsNullOrEmpty(mappingItem.CsvColumnName)) { //Map fields if mapping specified newMap.Name(mappingItem.CsvColumnName); } //And default values if it specified if (mappingItem.CustomValue != null) { var typeConverter = TypeDescriptor.GetConverter(propertyInfo.PropertyType); newMap.Default(typeConverter.ConvertFromString(mappingItem.CustomValue)); } PropertyMaps.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 csvPropertyMap = new CsvPropertyMap(typeof(CsvProduct).GetProperty("PropertyValues")); csvPropertyMap.Name(propertyCsvColumn); // create custom converter instance which will get the required record from the collection csvPropertyMap.UsingExpression <ICollection <coreModel.PropertyValue> >(null, propValues => { var propValue = propValues.FirstOrDefault(x => x.PropertyName == propertyCsvColumn); if (propValue != null) { return(propValue.Value != null ? propValue.Value.ToString() : string.Empty); } return(string.Empty); }); PropertyMaps.Add(csvPropertyMap); } var newPropMap = new CsvPropertyMap(typeof(CsvProduct).GetProperty("PropertyValues")); newPropMap.UsingExpression <ICollection <coreModel.PropertyValue> >(null, null).ConvertUsing(x => mappingCfg.PropertyCsvColumns.Select(column => new coreModel.PropertyValue { PropertyName = column, Value = x.GetField <string>(column) }).ToList()); PropertyMaps.Add(newPropMap); } }
public void AutoMap(IEnumerable <string> csvColumns) { CsvColumns = csvColumns.ToArray(); foreach (var propertyMap in PropertyMaps) { var entityColumnName = propertyMap.EntityColumnName; var betterMatchCsvColumn = csvColumns.Select(x => new { csvColumn = x, distance = x.ComputeLevenshteinDistance(entityColumnName) }) .Where(x => x.distance < 2) .OrderBy(x => x.distance) .Select(x => x.csvColumn) .FirstOrDefault(); if (betterMatchCsvColumn != null) { propertyMap.CsvColumnName = betterMatchCsvColumn; propertyMap.CustomValue = null; } else { propertyMap.CsvColumnName = null; } } //All not mapped properties may be a product property PropertyCsvColumns = csvColumns.Except(PropertyMaps.Where(x => x.CsvColumnName != null).Select(x => x.CsvColumnName)).ToArray(); //Generate ETag for identifying csv format ETag = string.Join(";", CsvColumns).GetMD5Hash(); }
public virtual CsvPropertyMap PropertyMap <T>(Expression <Func <T, object> > expression) { var property = ReflectionHelper.GetProperty(expression); var csvPropertyMap = PropertyMaps.SingleOrDefault(m => { if (m.Data.Property == property) { return(true); } if (m.Data.Property.Name != property.Name) { return(false); } if (m.Data.Property.DeclaringType.IsAssignableFrom(property.DeclaringType)) { return(true); } return(property.DeclaringType.IsAssignableFrom(m.Data.Property.DeclaringType)); }); if (csvPropertyMap != null) { return(csvPropertyMap); } var maxIndex = new CsvPropertyMap(property); maxIndex.Data.Index = GetMaxIndex() + 1; PropertyMaps.Add(maxIndex); return(maxIndex); }
private void CheckForPropertyMap(Type typeKey) { if (!PropertyMaps.ContainsKey(typeKey)) { PropertyMaps.Add(typeKey, new Dictionary <string, PropertyMappingExpression>()); } }
public void Seal(IConfigurationProvider configurationProvider) { if (_sealed) { return; } _sealed = true; foreach (var includedMemberTypeMap in _includedMembersTypeMaps) { includedMemberTypeMap.TypeMap.Seal(configurationProvider); ApplyIncludedMemberTypeMap(includedMemberTypeMap); } foreach (var inheritedTypeMap in _inheritedTypeMaps) { ApplyInheritedTypeMap(inheritedTypeMap); } _orderedPropertyMaps = PropertyMaps.OrderBy(map => map.MappingOrder).ToArray(); _propertyMaps.Clear(); MapExpression = CreateMapperLambda(configurationProvider, null); Features.Seal(configurationProvider); }
/// <summary> /// Get the largest index for the /// properties/fields and references. /// </summary> /// <returns>The max index.</returns> public virtual int GetMaxIndex() { if (ParameterMaps.Count == 0 && PropertyMaps.Count == 0 && ReferenceMaps.Count == 0) { return(-1); } var indexes = new List <int>(); if (ParameterMaps.Count > 0) { indexes.AddRange(ParameterMaps.Select(parameterMap => parameterMap.GetMaxIndex())); } if (PropertyMaps.Count > 0) { indexes.Add(PropertyMaps.Max(pm => pm.Data.Index)); } if (ReferenceMaps.Count > 0) { indexes.AddRange(ReferenceMaps.Select(referenceMap => referenceMap.GetMaxIndex())); } return(indexes.Max()); }
public void AddPropertyMap(MemberInfo destProperty, IEnumerable <MemberInfo> resolvers) { var propertyMap = new PropertyMap(destProperty, this); propertyMap.ChainMembers(resolvers); PropertyMaps.Add(propertyMap); }
public PropertyMap AddProperty(string property, string columnName) { var map = new PropertyMap(property, columnName); PropertyMaps.Add(map); return(map); }
/// <summary> /// Maps a non-member to a CSV field. This allows for writing /// data that isn't mapped to a class property/field. /// </summary> /// <returns>The property mapping.</returns> public virtual CsvPropertyMap Map() { var propertyMap = new CsvPropertyMap(null); propertyMap.Data.Index = GetMaxIndex() + 1; PropertyMaps.Add(propertyMap); return(propertyMap); }
private void FillPropertyMaps() { foreach (var map in _propertyMaps) { PropertyMaps.Add(map); } foreach (var linqPropertyMap in _linqPropertyMaps) { LinqPropertyMaps.Add(linqPropertyMap); } }
/// <summary> /// Maps a property to a CSV field. /// </summary> /// <param name="expression">The property to map.</param> /// <returns>The property mapping.</returns> protected virtual CsvPropertyMap Map(Expression <Func <T, object> > expression) { var property = ReflectionHelper.GetProperty(expression); if (PropertyMaps.Any(m => m.Data.Property == property)) { throw new CsvConfigurationException(string.Format("Property '{0}' has already been mapped.", property.Name)); } var propertyMap = new CsvPropertyMap(property); PropertyMaps.Add(propertyMap); return(propertyMap); }
/// <summary> /// Get the largest index for the /// properties and references. /// </summary> /// <returns>The max index.</returns> internal int GetMaxIndex() { if (PropertyMaps.Count == 0 && ReferenceMaps.Count == 0) { return(IndexStart); } var indexes = new List <int> { PropertyMaps.Max(pm => pm.Data.Index) }; indexes.AddRange(ReferenceMaps.Select(referenceMap => referenceMap.GetMaxIndex())); return(indexes.Max()); }
public PropertyMap FindOrCreatePropertyMapFor(MemberInfo destinationProperty) { var propertyMap = GetExistingPropertyMapFor(destinationProperty); if (propertyMap != null) { return(propertyMap); } propertyMap = new PropertyMap(destinationProperty, this); PropertyMaps.Add(propertyMap); return(propertyMap); }
/// <summary> /// Maps a property to a CSV field. /// </summary> /// <param name="property">The property to map.</param> /// <returns>The property mapping.</returns> public virtual CsvPropertyMap Map(PropertyInfo property) { var existingMap = PropertyMaps.Find(property); if (existingMap != null) { return(existingMap); } var propertyMap = new CsvPropertyMap(property); propertyMap.Data.Index = GetMaxIndex() + 1; PropertyMaps.Add(propertyMap); return(propertyMap); }
public RelationshipMap(string tblName) { var baseType = typeof(Entity); var props = baseType.GetProperties(); foreach (var p in props) { PropertyMaps.Add(new ManualPropertyMap { CaseSensitive = true, ColumnName = $"{tblName}.{p.Name}", Ignored = false, PropertyInfo = p }); } }
/// <summary> /// Creates and returns a <see cref="QueryMapDataModel"/> from the current <see cref="QueryMap"/> /// </summary> /// <returns></returns> public QueryMapDataModel ToDataModel() => new QueryMapDataModel() { Id = Id, DatabaseId = DatabaseOptions.Id, TableNames = Tables.Select(x => x.TableName).ToArray(), Joins = Joins.Select(x => x.ToDataModel()).ToArray(), Color = Color, Description = Description, Name = Name, // Set the column maps PropertyMaps = PropertyMaps.Select(x => x.ToDataModel()).ToArray(), // Set the data grid presenter maps DataGridPresenterMaps = DataGridPresenterMaps.Select(x => x.ToDataModel()).ToArray(), };
/// <summary> /// Maps a property to a Excel field. /// </summary> /// <param name="property">Property to map</param> /// <returns>The property mapping.</returns> private ExcelPropertyMap Map( PropertyInfo property) { var existingMap = PropertyMaps.SingleOrDefault(m => m.Data.Property == property); if (existingMap != null) { return(existingMap); } var propertyMap = new ExcelPropertyMap(property); propertyMap.Data.Index = GetMaxIndex() + 1; PropertyMaps.Add(propertyMap); return(propertyMap); }
/// <summary> /// Get the largest index for the /// properties and references. /// </summary> /// <returns>The max index.</returns> internal int GetMaxIndex() { if (PropertyMaps.Count == 0 && ReferenceMaps.Count == 0) { return(-1); } var nums = new List <int>(); if (PropertyMaps.Count > 0) { nums.Add(PropertyMaps.Max(pm => pm.Data.Index)); } nums.AddRange( from referenceMap in ReferenceMaps select referenceMap.GetMaxIndex()); return(nums.Max()); }
public PropertyMap GetExistingPropertyMapFor(MemberInfo destinationProperty) { if (!destinationProperty.DeclaringType.IsAssignableFrom(DestinationType)) { return(null); } var propertyMap = PropertyMaps.FirstOrDefault(pm => pm.DestMember.Name.Equals(destinationProperty.Name)); if (propertyMap != null) { return(propertyMap); } propertyMap = _inheritedMaps.FirstOrDefault(pm => pm.DestMember.Name.Equals(destinationProperty.Name)); if (propertyMap == null) { return(null); } var propertyInfo = propertyMap.DestMember as PropertyInfo; if (propertyInfo == null) { return(propertyMap); } var baseAccessor = propertyInfo.GetMethod; if (baseAccessor.IsAbstract || baseAccessor.IsVirtual) { return(propertyMap); } var accessor = ((PropertyInfo)destinationProperty).GetMethod; if (baseAccessor.DeclaringType == accessor.DeclaringType) { return(propertyMap); } return(null); }
/// <summary> /// Maps a property to a CSV field. /// </summary> /// <param name="expression">The property to map.</param> /// <returns>The property mapping.</returns> protected virtual CsvPropertyMap Map(Expression <Func <T, object> > expression) { var property = ReflectionHelper.GetProperty(expression); var existingMap = PropertyMaps.SingleOrDefault(m => m.Data.Property == property); if (existingMap != null) { return(existingMap); } var propertyMap = new CsvPropertyMap(property); propertyMap.Data.Index = GetMaxIndex() + 1; PropertyMaps.Add(propertyMap); return(propertyMap); }
/// <summary> /// Maps a property/field to a CSV field. /// </summary> /// <param name="member">The property/field to map.</param> /// <param name="useExistingMap">If true, an existing map will be used if available. /// If false, a new map is created for the same property/field.</param> /// <returns>The property/field mapping.</returns> public virtual CsvPropertyMap Map(MemberInfo member, bool useExistingMap = true) { if (useExistingMap) { var existingMap = PropertyMaps.Find(member); if (existingMap != null) { return(existingMap); } } var propertyMap = new CsvPropertyMap(member); propertyMap.Data.Index = GetMaxIndex() + 1; PropertyMaps.Add(propertyMap); return(propertyMap); }
public string GetPropertyMappedFrom(string propertyName, Type typeFrom) { var mapFromProperty = propertyName; if (PropertyMaps.Any(pm => pm.Type2Property == propertyName && pm.Type1 == typeFrom)) { mapFromProperty = PropertyMaps.First(pm => pm.Type2Property == propertyName && pm.Type1 == typeFrom).Type1Property; } else if (PropertyMaps.Any(pm => pm.Type1Property == propertyName && pm.Type2 == typeFrom)) { mapFromProperty = PropertyMaps.First(pm => pm.Type1Property == propertyName && pm.Type2 == typeFrom).Type2Property; } return(mapFromProperty); }
/// <summary> /// Maps a property/field to a CSV field. /// </summary> /// <param name="classType">The type of the class this map is for. This may not be the same type /// as the member.DeclaringType or the current ClassType due to nested property mappings.</param> /// <param name="member">The property/field to map.</param> /// <param name="useExistingMap">If true, an existing map will be used if available. /// If false, a new map is created for the same property/field.</param> /// <returns>The property/field mapping.</returns> public CsvPropertyMap Map(Type classType, MemberInfo member, bool useExistingMap = true) { if (useExistingMap) { var existingMap = PropertyMaps.Find(member); if (existingMap != null) { return(existingMap); } } var propertyMap = CsvPropertyMap.CreateGeneric(classType, member); propertyMap.Data.Index = GetMaxIndex() + 1; PropertyMaps.Add(propertyMap); return(propertyMap); }
public string[] GetUnmappedPropertyNames() { Func <PropertyMap, string> getFunc = pm => ConfiguredMemberList == MemberList.Destination ? pm.DestMember.Name : pm.CustomExpression == null && pm.SrcMember != null ? pm.SrcMember.Name : pm.DestMember.Name; var autoMappedProperties = PropertyMaps.Where(pm => pm.IsMapped()) .Select(getFunc).ToList(); var inheritedProperties = _inheritedMaps.Where(pm => pm.IsMapped()) .Select(getFunc).ToList(); IEnumerable <string> properties; if (ConfiguredMemberList == MemberList.Destination) { properties = DestinationTypeDetails.PublicWriteAccessors .Select(p => p.Name) .Except(autoMappedProperties) .Except(inheritedProperties); } else { var redirectedSourceMembers = PropertyMaps .Where(pm => pm.IsMapped() && pm.SrcMember != null && pm.SrcMember.Name != pm.DestMember.Name) .Select(pm => pm.SrcMember.Name); var ignoredSourceMembers = _sourceMemberConfigs .Where(smc => smc.IsIgnored()) .Select(pm => pm.SourceMember.Name).ToList(); properties = SourceTypeDetails.PublicReadAccessors .Select(p => p.Name) .Except(autoMappedProperties) .Except(inheritedProperties) .Except(redirectedSourceMembers) .Except(ignoredSourceMembers); } return(properties.Where(memberName => !IgnorePropertiesStartingWith.Any(memberName.StartsWith)).ToArray()); }
public void Seal(TypeMapRegistry typeMapRegistry, IConfigurationProvider configurationProvider) { if (_sealed) { return; } _sealed = true; foreach (var inheritedTypeMap in _inheritedTypeMaps) { ApplyInheritedTypeMap(inheritedTypeMap); } _orderedPropertyMaps = PropertyMaps .Union(_inheritedMaps) .OrderBy(map => map.MappingOrder).ToArray(); //MapExpression = new TypeMapPlanBuilder(configurationProvider, typeMapRegistry, this).CreateMapperLambda(); }
public virtual CsvPropertyMap PropertyMap <T>(Expression <Func <T, object> > expression) { var property = ReflectionHelper.GetProperty(expression); var existingMap = PropertyMaps.SingleOrDefault(m => m.Data.Property == property || m.Data.Property.Name == property.Name && (m.Data.Property.DeclaringType.IsAssignableFrom(property.DeclaringType) || property.DeclaringType.IsAssignableFrom(m.Data.Property.DeclaringType))); if (existingMap != null) { return(existingMap); } var propertyMap = new CsvPropertyMap(property); propertyMap.Data.Index = GetMaxIndex() + 1; PropertyMaps.Add(propertyMap); return(propertyMap); }
private void ApplyInheritedTypeMap(TypeMap inheritedTypeMap) { foreach (var inheritedMappedProperty in inheritedTypeMap.PropertyMaps.Where(m => m.IsMapped)) { var conventionPropertyMap = PropertyMaps .SingleOrDefault(m => m.DestinationName == inheritedMappedProperty.DestinationName); if (conventionPropertyMap != null) { conventionPropertyMap.ApplyInheritedPropertyMap(inheritedMappedProperty); } else { var propertyMap = new PropertyMap(inheritedMappedProperty, this); _inheritedMaps.Add(propertyMap); } } //Include BeforeMap foreach (var beforeMapAction in inheritedTypeMap._beforeMapActions) { AddBeforeMapAction(beforeMapAction); } //Include AfterMap foreach (var afterMapAction in inheritedTypeMap._afterMapActions) { AddAfterMapAction(afterMapAction); } var notOverridenSourceConfigs = inheritedTypeMap._sourceMemberConfigs.Where( baseConfig => _sourceMemberConfigs.All(derivedConfig => derivedConfig.SourceMember != baseConfig.SourceMember)); _sourceMemberConfigs.AddRange(notOverridenSourceConfigs); var notOverridenPathMaps = inheritedTypeMap.PathMaps.Where( baseConfig => PathMaps.All(derivedConfig => derivedConfig.MemberPath != baseConfig.MemberPath)); _pathMaps.AddRange(notOverridenPathMaps); }
public string[] GetUnmappedPropertyNames() { var autoMappedProperties = GetPropertyNames(PropertyMaps); IEnumerable <string> properties; if (ConfiguredMemberList == MemberList.Destination) { properties = DestinationTypeDetails.PublicWriteAccessors .Select(p => p.Name) .Except(autoMappedProperties) .Except(PathMaps.Select(p => p.MemberPath.First.Name)); } else { var redirectedSourceMembers = PropertyMaps .Where(pm => pm.IsMapped && pm.SourceMember != null && pm.SourceMember.Name != pm.DestinationName) .Select(pm => pm.SourceMember.Name); var ignoredSourceMembers = SourceMemberConfigs .Where(smc => smc.IsIgnored()) .Select(pm => pm.SourceMember.Name).ToList(); properties = SourceTypeDetails.PublicReadAccessors .Select(p => p.Name) .Except(autoMappedProperties) .Except(redirectedSourceMembers) .Except(ignoredSourceMembers); } return(properties.Where(memberName => !Profile.GlobalIgnores.Any(memberName.StartsWith)).ToArray()); string GetPropertyName(PropertyMap pm) => ConfiguredMemberList == MemberList.Destination ? pm.DestinationName : pm.SourceMember != null ? pm.SourceMember.Name : pm.DestinationName; string[] GetPropertyNames(IEnumerable <PropertyMap> propertyMaps) => propertyMaps.Where(pm => pm.IsMapped).Select(GetPropertyName).ToArray(); }
public ProductMap(string[] allColumns, webModel.CsvImportMappingItem[] mappingConfiguration) { var attributePropertyNames = allColumns.Except(mappingConfiguration.Select(x => x.CsvColumnName)); foreach (var mappingConfigurationItem in mappingConfiguration) { var propertyInfo = typeof(coreModel.CatalogProduct).GetProperty(mappingConfigurationItem.EntityColumnName); var newMap = new CsvPropertyMap(propertyInfo); newMap.Name(mappingConfigurationItem.CsvColumnName); PropertyMaps.Add(newMap); } var categoryMappingItem = mappingConfiguration.First(x => x.EntityColumnName == "Category"); var editorialReviewMappingItem = mappingConfiguration.First(x => x.EntityColumnName == "Reviews"); Map(x => x.Category).ConvertUsing(x => new coreModel.Category { Path = x.GetField <string>(categoryMappingItem.CsvColumnName) }); Map(x => x.Reviews).ConvertUsing(x => new coreModel.EditorialReview[] { new coreModel.EditorialReview { Content = x.GetField <string>(editorialReviewMappingItem.CsvColumnName) } }); Map(x => x.PropertyValues).ConvertUsing(x => attributePropertyNames.Select(column => new coreModel.PropertyValue { PropertyName = column, Value = x.GetField <string>(column) }).ToList()); }
public PropertyMap[] GetPropertyMaps() { return(_orderedPropertyMaps ?? PropertyMaps.Concat(_inheritedMaps).ToArray()); }