public void Add_single_feature_with_reverse()
{
var featureA = new MappingExpressionFeatureA(1);
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Source, Dest>()
.SetFeature(featureA)
.ReverseMap();
});
var typeMap = config.FindTypeMapFor <Source, Dest>();
typeMap.Features.Count().ShouldBe(1);
var typeMapReverse = config.FindTypeMapFor <Dest, Source>();
typeMapReverse.Features.Count().ShouldBe(0);
Validate <TypeMapFeatureA>(featureA);
void Validate <TFeature>(MappingExpressionFeatureBase feature)
where TFeature : TypeMapFeatureBase
{
feature.ConfigureTypeMaps.ShouldBeOfLength(1);
feature.ReverseExecutedCount.ShouldBe(1);
var typeMapFeature = typeMap.Features.Get <TFeature>();
typeMapFeature.ShouldNotBeNull();
typeMapFeature.Value.ShouldBe(feature.Value);
typeMapFeature.SealedCount.ShouldBe(1);
}
}
public void Adding_same_feature_multiple_times_should_replace_eachother()
{
var featureA = new MappingExpressionFeatureA(1);
var featureB = new MappingExpressionFeatureB(1);
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Source, Dest>()
.AddOrUpdateFeature(new MappingExpressionFeatureA(3))
.AddOrUpdateFeature(new MappingExpressionFeatureA(2))
.AddOrUpdateFeature(featureA)
.AddOrUpdateFeature(new MappingExpressionFeatureB(3))
.AddOrUpdateFeature(new MappingExpressionFeatureB(2))
.AddOrUpdateFeature(featureB)
.ReverseMap();
});
var typeMap = config.FindTypeMapFor <Source, Dest>();
typeMap.Features.Count().ShouldBe(2);
var typeMapReverse = config.FindTypeMapFor <Dest, Source>();
typeMapReverse.Features.Count().ShouldBe(2);
Validate(featureA);
Validate(featureB);
void Validate(MappingExpressionFeatureBase feature)
{
feature.ConfigureTypeMaps.ShouldBeOfLength(1);
feature.ReverseMaps.ShouldBeOfLength(1);
}
}
static public void AssertConfigurationIsValid <TSource, TDestination>()
{
TypeMap map = MapperConfiguration.FindTypeMapFor <TSource, TDestination>();
NUnit.Framework.Assert.IsNotNull(map, "Could not find type map from {0} to {1}", typeof(TSource), typeof(TDestination));
MapperConfiguration.AssertConfigurationIsValid(map);
}
public void Adding_same_feature_should_replace_eachother()
{
var featureA = new MappingExpressionFeatureA(1);
var featureB = new MappingExpressionFeatureB(2);
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Source, Dest>()
.SetFeature(new MappingExpressionFeatureA(3))
.SetFeature(new MappingExpressionFeatureA(2))
.SetFeature(featureA)
.SetFeature(new MappingExpressionFeatureB(3))
.SetFeature(new MappingExpressionFeatureB(2))
.SetFeature(featureB)
.ReverseMap();
});
var typeMap = config.FindTypeMapFor <Source, Dest>();
typeMap.Features.Count().ShouldBe(2);
var typeMapReverse = config.ResolveTypeMap(typeof(Dest), typeof(Source));
typeMapReverse.Features.Count().ShouldBe(0);
Validate(featureA);
Validate(featureB);
void Validate(MappingExpressionFeatureBase feature)
{
feature.ConfigureTypeMaps.ShouldBeOfLength(1);
feature.ReverseExecutedCount.ShouldBe(1);
}
}
public TwoWayMapper(Action <IMapperConfigurationExpression> automapperExpression)
: base(automapperExpression)
{
if (MapperConfiguration.FindTypeMapFor <TModel, TEntity>() == null)
{
throw new Exception($"Missing type map for {typeof(TModel).Name} -> {typeof(TEntity).Name}");
}
}
public void Add_multiple_features_with_reverse_overriden()
{
var featureA = new MappingExpressionFeatureA(1);
var featureB = new MappingExpressionFeatureB(2);
var overridenFeatureB = new MappingExpressionFeatureB(10);
var config = new MapperConfiguration(
cfg =>
{
cfg.CreateMap <Source, Dest>()
.SetFeature(featureA)
.SetFeature(featureB)
.ReverseMap()
.SetFeature(overridenFeatureB);
}
);
var typeMap = config.FindTypeMapFor <Source, Dest>();
typeMap.Features.Count().ShouldBe(2);
var typeMapReverse = config.FindTypeMapFor <Dest, Source>();
typeMapReverse.Features.Count().ShouldBe(2);
Validate <TypeMapFeatureA>(featureA, typeMap);
Validate <TypeMapFeatureB>(featureB, typeMap);
Validate <TypeMapFeatureA>(featureA, typeMapReverse, value: featureA.Value + 1);
Validate <TypeMapFeatureB>(overridenFeatureB, typeMapReverse, 0);
void Validate <TFeature>(
MappingExpressionFeatureBase feature,
TypeMap map,
int reverseExecutedCount = 1,
int?value = null
) where TFeature : TypeMapFeatureBase
{
feature.ConfigureTypeMaps.ShouldBeOfLength(1);
feature.ReverseMaps.ShouldBeOfLength(reverseExecutedCount);
var typeMapFeature = map.Features.Get <TFeature>();
typeMapFeature.ShouldNotBeNull();
typeMapFeature.Value.ShouldBe(value ?? feature.Value);
typeMapFeature.SealedCount.ShouldBe(1);
}
}
public void Should_set_inline_accordingly()
{
var configuration = new MapperConfiguration(cfg =>
{
cfg.Advanced.MaxExecutionPlanDepth = 2;
cfg.CreateMap <Source, Destination>();
cfg.CreateMap <Source1, Destination1>();
cfg.CreateMap <Source2, Destination2>();
cfg.CreateMap <Source3, Destination3>();
cfg.CreateMap <Source4, Destination4>();
cfg.CreateMap <Source5, Destination5>();
cfg.CreateMap <Source6, Destination6>();
});
TypeMap map;
map = configuration.FindTypeMapFor <Source, Destination>();
map.GetPropertyMaps()[0].Inline.ShouldBeTrue();
map = configuration.FindTypeMapFor <Source1, Destination1>();
map.GetPropertyMaps()[0].Inline.ShouldBeTrue();
map = configuration.FindTypeMapFor <Source2, Destination2>();
map.GetPropertyMaps()[0].Inline.ShouldBeFalse();
map = configuration.FindTypeMapFor <Source3, Destination3>();
map.GetPropertyMaps()[0].Inline.ShouldBeTrue();
map = configuration.FindTypeMapFor <Source4, Destination4>();
map.GetPropertyMaps()[0].Inline.ShouldBeTrue();
map = configuration.FindTypeMapFor <Source5, Destination5>();
map.GetPropertyMaps()[0].Inline.ShouldBeFalse();
}
private static void AddAutoMapperClasses(this IServiceCollection services, IEnumerable <Assembly> assembliesToScan)
{
assembliesToScan = assembliesToScan as Assembly[] ?? assembliesToScan.ToArray();
var allTypes = assembliesToScan.SelectMany(a => { try { return(a.ExportedTypes); } catch { return(new List <System.Type>()); } }).ToArray();
var profiles =
allTypes
.Where(t => typeof(Profile).GetTypeInfo().IsAssignableFrom(t.GetTypeInfo()))
.Where(t => !t.GetTypeInfo().IsAbstract);
var mapperConfigurationExpression = new MapperConfigurationExpression();
//create maps based on existing profiles
foreach (var profile in profiles)
{
mapperConfigurationExpression.AddProfile(profile);
}
var config = new MapperConfiguration(mapperConfigurationExpression);
//create maps based on generic business services
var businessServices =
allTypes
.Where(t => t.GetInterfaces().Contains(typeof(_IBusinessService)))
.Where(t => !t.GetTypeInfo().IsAbstract);
foreach (var businessService in businessServices)
{
foreach (Type SourceType in businessService.GetTypeInfo().BaseType.GenericTypeArguments)
{
foreach (Type DestinationType in businessService.GetTypeInfo().BaseType.GenericTypeArguments)
{
if (config.FindTypeMapFor(SourceType, DestinationType) == null)
{
mapperConfigurationExpression.CreateProfile(SourceType.FullName.Replace('.', '_') + '_' + DestinationType.FullName.Replace('.', '_'), (profileConfig) =>
{
profileConfig.CreateMap(SourceType, DestinationType);
});
}
else
{
}
}
}
}
//other configuration
//mapperConfigurationExpression.CreateMissingTypeMaps = true;
//mapperConfigurationExpression.ForAllMaps((a, b) => {
// foreach(prop)
//});
config = new MapperConfiguration(mapperConfigurationExpression);
services.AddSingleton(sp => config.CreateMapper());
}
public static PropertyInfo[] GetUnmappedDestinationMembers <TSource, TDest>(MapperConfiguration config)
{
TypeMap typeMap = config.FindTypeMapFor <TSource, TDest>();
var memberMaps = typeMap.MemberMaps.Where(m => !m.Ignored);
Func <IMemberMap, string> extractDestinationMemberName = m =>
{
string name = m.DestinationName;
return(name);
};
var mappedProperties = memberMaps.Select(m => extractDestinationMemberName(m)).Where(n => n != null).ToArray();
var unmappedProperties = typeof(TDest).GetProperties().Where(p => !mappedProperties.Contains(p.Name)).ToArray();
return(unmappedProperties);
}
public static PropertyInfo[] GetUnmappedSourceMembers <TSource, TDest>(MapperConfiguration config)
{
TypeMap typeMap = config.FindTypeMapFor <TSource, TDest>();
var memberMaps = typeMap.MemberMaps.Where(m => !m.Ignored);
Func <IMemberMap, string> extractSourceMemberName = m =>
{
string name = m.SourceMember?.Name;
if (name == null)
{
name = ((MemberExpression)m.ValueResolverConfig?.SourceMember?.Body)?.Member.Name;
}
return(name);
};
var mappedProperties = memberMaps.Select(m => extractSourceMemberName(m)).Where(n => n != null).ToArray();
var unmappedProperties = typeof(TSource).GetProperties().Where(p => !mappedProperties.Contains(p.Name)).ToArray();
return(unmappedProperties);
}
public void Add_multiple_features()
{
var featureA = new MappingExpressionFeatureA(1);
var featureB = new MappingExpressionFeatureB(2);
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMissingTypeMaps = true;
cfg.CreateMap <Source, Dest>()
.SetFeature(featureA)
.SetFeature(featureB);
});
var typeMap = config.FindTypeMapFor <Source, Dest>();
typeMap.Features.Count().ShouldBe(2);
var typeMapReverse = config.ResolveTypeMap(typeof(Dest), typeof(Source));
typeMapReverse.Features.Count().ShouldBe(0);
Validate <TypeMapFeatureA>(featureA);
Validate <TypeMapFeatureB>(featureB);
void Validate <TFeature>(MappingExpressionFeatureBase feature)
where TFeature : TypeMapFeatureBase
{
feature.ConfigureTypeMaps.ShouldBeOfLength(1);
feature.ReverseExecutedCount.ShouldBe(0);
var typeMapFeature = typeMap.Features.Get <TFeature>();
typeMapFeature.ShouldNotBeNull();
typeMapFeature.Value.ShouldBe(feature.Value);
typeMapFeature.SealedCount.ShouldBe(1);
}
}
public static object ConvertToVersion(object source, string apiVersion)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var type = source.GetType();
var attr = GetKubernetesEntityAttribute(type);
if (attr.ApiVersion == apiVersion)
{
return(source);
}
if (!KindVersionsMap.TryGetValue(attr.Kind, out var kindVersions))
{
throw new InvalidOperationException($"Version converter does not have any registered types for Kind `{attr.Kind}`");
}
if (!kindVersions.TryGetValue(apiVersion, out var targetType) || !kindVersions.TryGetValue(attr.ApiVersion, out var sourceType) || MapperConfiguration.FindTypeMapFor(sourceType, targetType) == null)
{
throw new InvalidOperationException($"There is no conversion mapping registered for Kind `{attr.Kind}` from ApiVersion {attr.ApiVersion} to {apiVersion}");
}
return(Mapper.Map(source, sourceType, targetType));
}
public void MappingConfigureTests()
{
var configure = new MapperConfiguration(cfg => cfg.CreateMapper <Source, Destination>());
Assert.IsNotNull(configure.FindTypeMapFor <Source, Destination>());
}
public void Should_find_configured_type_map_when_two_types_are_configured()
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <Source, Destination>());
config.FindTypeMapFor <Source, Destination>().ShouldNotBeNull();
}
public void Should_find_configured_type_map_when_two_types_are_configured()
{
var config = new MapperConfiguration(cfg => cfg.CreateMap<Source, Destination>());
config.FindTypeMapFor<Source, Destination>().ShouldNotBeNull();
}
public Dictionary <string, MapExpression <TEntity> > GetModelMappings <TEntity, TViewModel>(Dictionary <string, MapExpression <TEntity> > mappings = null)
{
if (SameTypes <TEntity, TViewModel>())
{
return(null);
}
var map = _mapperConfiguration?.FindTypeMapFor <TEntity, TViewModel>();
if (map == null)
{
return(null);
}
mappings = mappings ?? new Dictionary <string, MapExpression <TEntity> >();
// Custom expressions because they do not map field to field
foreach (var propertyMap in map.GetPropertyMaps().Where(pm => pm.CustomExpression != null))
{
// Get the linq expression body
string body = propertyMap.CustomExpression.Body.ToString();
// Get the item tag
string tag = propertyMap.CustomExpression.Parameters[0].Name;
string destination = body.Replace($"{tag}.", string.Empty);
string source = propertyMap.DestinationProperty.Name;
var customExpression = new MapExpression <TEntity>
{
Path = destination,
Expression = propertyMap.CustomExpression.ToTypedExpression <TEntity>()
};
if (!mappings.ContainsKey(source))
{
mappings.Add(source, customExpression);
}
}
foreach (var propertyMap in map.GetPropertyMaps().Where(pm => pm.CustomExpression == null))
{
var customResolver = propertyMap.ValueResolverConfig?.Instance;
if (customResolver is IKendoGridExValueResolver <TEntity> )
{
string source = propertyMap.DestinationProperty.Name;
IKendoGridExValueResolver <TEntity> kendoResolver = customResolver as IKendoGridExValueResolver <TEntity>;
string destination = kendoResolver.DestinationProperty;
var expression = propertyMap.CustomExpression != null?propertyMap.CustomExpression.ToTypedExpression <TEntity>() : kendoResolver.Expression;
var customExpression = new MapExpression <TEntity>
{
Path = destination,
Expression = expression
};
if (!mappings.ContainsKey(source))
{
mappings.Add(source, customExpression);
}
}
}
return(mappings);
}