private void Configure(TypeMapRegistry typeMapRegistry, TypeMap typeMap) { foreach (var action in _allTypeMapActions) { var expression = new MappingExpression(typeMap.TypePair, typeMap.ConfiguredMemberList); action(typeMap, expression); expression.Configure(this, typeMap); } foreach (var action in _allPropertyMapActions) { foreach (var propertyMap in typeMap.GetPropertyMaps()) { var memberExpression = new MappingExpression.MemberConfigurationExpression(propertyMap.DestMember, typeMap.SourceType); action(propertyMap, memberExpression); memberExpression.Configure(typeMap); } } ApplyBaseMaps(typeMapRegistry, typeMap, typeMap); ApplyDerivedMaps(typeMapRegistry, typeMap, typeMap); }
/// <summary> /// Initializes a new instance of the <see cref="ChecklistFieldMapping"/> class. /// </summary> /// <param name="property"> /// The property. /// </param> /// <param name="valueExpression"> /// The value expression. /// </param> /// <param name="childMappings"> /// The child mappings. /// </param> /// <param name="dynamicTypeManager"> /// The dynamic type manager. /// </param> public ChecklistFieldMapping( PropertyInfo property, MappingExpression valueExpression, IEnumerable<IProcessFieldMapping> childMappings, IDynamicTypeManager dynamicTypeManager) { if (property == null) throw new ArgumentNullException("property"); var checklistAttribute = property.GetCustomAttribute<ChecklistFieldAttribute>(); if (checklistAttribute == null) throw new ArgumentException("The specified property is not a checklist field."); if (childMappings == null) throw new ArgumentNullException("childMappings"); var childMappingsArray = childMappings.ToArray(); if (childMappingsArray.All(m => !m.IsKey)) throw new ArgumentException("At least one key field should be specified."); if (dynamicTypeManager == null) throw new ArgumentNullException("dynamicTypeManager"); _property = property; _valueExpression = valueExpression; _childMappings = childMappingsArray; _dynamicTypeManager = dynamicTypeManager; _answerProcessName = checklistAttribute.AnswerProcessName; }
public void Custom_Mapping_Valid() { // arrange var model = new Model2 { EmailAddress = "*****@*****.**", Number = 21, Category = "dev" }; var expression = new MappingExpression <Model2>(); expression .ForMember(m => m.Category, cat => !string.IsNullOrWhiteSpace(cat)) .ForMember(m => m.EmailAddress, email => email.Contains("@")) .ForMember(m => m.Number, num => num >= 18); // act var result = expression.Validate(model, _settings); // assert result.Should().NotBeNull(); result.Success.Should().BeTrue(); result.Errors.Count.Should().Be(0); }
private void Configure(TypeMap typeMap, IConfigurationProvider configurationProvider) { foreach (var action in AllTypeMapActions) { var expression = new MappingExpression(typeMap.Types, typeMap.ConfiguredMemberList); action(typeMap, expression); expression.Configure(typeMap); } foreach (var action in AllPropertyMapActions) { foreach (var propertyMap in typeMap.PropertyMaps) { var memberExpression = new MappingExpression.MemberConfigurationExpression(propertyMap.DestinationMember, typeMap.SourceType); action(propertyMap, memberExpression); memberExpression.Configure(typeMap); } } ApplyBaseMaps(typeMap, typeMap, configurationProvider); ApplyDerivedMaps(typeMap, typeMap, configurationProvider); ApplyMemberMaps(typeMap, configurationProvider); }
/// <summary> /// Initializes a new instance of the <see cref="MultiCrossReferenceFieldMapping"/> class. /// </summary> /// <param name="property"> /// The property. /// </param> /// <param name="valueExpression"> /// The value expression. /// </param> /// <param name="childMappings"> /// The child mappings. /// </param> /// <param name="dynamicTypeManager"> /// The dynamic type manager. /// </param> /// <param name="runtimeDatabase"> /// The runtime database. /// </param> public MultiCrossReferenceFieldMapping( PropertyInfo property, MappingExpression valueExpression, IEnumerable<IProcessFieldMapping> childMappings, IDynamicTypeManager dynamicTypeManager, IRuntimeDatabase runtimeDatabase) { if (property == null) throw new ArgumentNullException("property"); var crAttribute = property.GetCustomAttribute<CrossRefFieldAttribute>(); if (crAttribute == null || !crAttribute.AllowMultiple) throw new ArgumentException("The specified property is not a multi cross reference field."); if (childMappings == null) throw new ArgumentNullException("childMappings"); var childMappingsArray = childMappings.ToArray(); if (childMappingsArray.All(m => !m.IsKey)) throw new ArgumentException("At least one key field should be specified."); if (dynamicTypeManager == null) throw new ArgumentNullException("dynamicTypeManager"); if (runtimeDatabase == null) throw new ArgumentNullException("runtimeDatabase"); _property = property; _valueExpression = valueExpression; _childMappings = childMappingsArray; _dynamicTypeManager = dynamicTypeManager; _runtimeDatabase = runtimeDatabase; _referencedProcessName = crAttribute.ReferenceTableName; }
/// <summary> /// Initializes a new instance of the <see cref="FileFieldMapping"/> class. /// </summary> /// <param name="property"> /// The property. /// </param> /// <param name="nameExpression"> /// The name expression. /// </param> /// <param name="contentExpression"> /// The content expression. /// </param> /// <param name="locationExpression"> /// The location expression. /// </param> /// <param name="typeConverter"> /// The type converter. /// </param> /// <param name="fileManager"> /// The file manager. /// </param> public FileFieldMapping( PropertyInfo property, MappingExpression nameExpression, MappingExpression contentExpression, MappingExpression locationExpression, ITypeConverter typeConverter, IFileManager fileManager) { if (property == null) throw new ArgumentNullException("property"); if (!typeof(IFileProcess).IsAssignableFrom(property.PropertyType)) throw new ArgumentException("The specified property is not a file field."); if (typeConverter == null) throw new ArgumentNullException("typeConverter"); if (fileManager == null) throw new ArgumentNullException("fileManager"); _property = property; _nameExpression = nameExpression; _contentExpression = contentExpression; _locationExpression = locationExpression; _typeConverter = typeConverter; _fileManager = fileManager; }
/// <summary> /// Initializes a new instance of the <see cref="SingleCrossReferenceFieldMapping"/> class. /// </summary> /// <param name="property"> /// The property. /// </param> /// <param name="valueExpression"> /// The value expression. /// </param> /// <param name="isKey"> /// Specifies whether this is a key mapping. /// </param> /// <param name="typeConverter"> /// The type converter. /// </param> /// <param name="dynamicTypeManager"> /// The dynamic type manager. /// </param> /// <param name="runtimeDatabase"> /// The runtime database. /// </param> /// <param name="childMappings"> /// The child mappings. /// </param> public SingleCrossReferenceFieldMapping( PropertyInfo property, MappingExpression valueExpression, bool isKey, ITypeConverter typeConverter, IDynamicTypeManager dynamicTypeManager, IRuntimeDatabase runtimeDatabase, IEnumerable<IProcessFieldMapping> childMappings) { if (property == null) throw new ArgumentNullException("property"); var crAttribute = property.GetCustomAttribute<CrossRefFieldAttribute>(); if (crAttribute == null || crAttribute.AllowMultiple || !typeof(int?).IsAssignableFrom(property.PropertyType)) throw new ArgumentException("The specified property is not a single cross reference field."); if (typeConverter == null) throw new ArgumentNullException("typeConverter"); if (dynamicTypeManager == null) throw new ArgumentNullException("dynamicTypeManager"); if (runtimeDatabase == null) throw new ArgumentNullException("runtimeDatabase"); _property = property; _valueExpression = valueExpression; _isKey = isKey; _typeConverter = typeConverter; _dynamicTypeManager = dynamicTypeManager; _runtimeDatabase = runtimeDatabase; _childMappings = (childMappings ?? Enumerable.Empty<IProcessFieldMapping>()).ToArray(); _referencedProcessName = crAttribute.ReferenceTableName; }
public IMappingExpression <TSource, TDestination> ConfigureMap(MemberList memberList) { var typeMapConfiguration = new MappingExpression <TSource, TDestination>(memberList); InlineConfiguration = typeMapConfiguration; return(typeMapConfiguration); }
public TDest Map <TSource, TDest>(TSource source, TDest destination) { EnsureMappingConfigured <TSource, TDest>(); MappingExpression <TSource, TDest> .Apply(source, destination); return(destination); }
private IMappingExpression <TSource, TDestination> CreateMappingExpression <TSource, TDestination>(MemberList memberList) { var mappingExp = new MappingExpression <TSource, TDestination>(memberList); _typeMapConfigs.Add(mappingExp); return(mappingExp); }
private IMappingExpression <TSource, TDestination> CreateMappingExpression <TSource, TDestination>(TypeMap typeMap) { var mappingExp = new MappingExpression <TSource, TDestination>(typeMap, ServiceCtor, this); var type = (typeMap.ConfiguredMemberList == MemberList.Destination) ? typeof(TDestination) : typeof(TSource); return(Ignore(mappingExp, type)); }
public TDest Map <TSource, TDest>(TSource source) where TDest : new() { EnsureMappingConfigured <TSource, TDest>(); var destination = new TDest(); MappingExpression <TSource, TDest> .Apply(source, destination); return(destination); }
/// <summary> /// Creates a map with the specified mapper & metadata /// </summary> /// <typeparam name="TS"></typeparam> /// <typeparam name="TT"></typeparam> /// <param name="engine"></param> /// <param name="mapper"></param> /// <param name="metadata"></param> /// <returns></returns> public static IMappingExpression <TS, TT> CreateMap <TS, TT>(this AbstractFluentMappingEngine engine, ITypeMapper <TS, TT> mapper, TypeMapperMetadata metadata) { engine.AddMap(mapper, metadata); //create enumerable type map for the types automatically if they aren't already IEnumerable engine.CreateEnumerableMap <TS, TT>(); var expression = new MappingExpression <TS, TT>(mapper.MappingContext); return(expression); }
/// <summary> /// Initializes a new instance of the <see cref="SimpleValueCalculator"/> class. /// </summary> /// <param name="valueExpression"> /// The value expression. /// </param> /// <param name="valueType"> /// The value type. /// </param> /// <param name="typeConverter"> /// The type converter. /// </param> public SimpleValueCalculator(MappingExpression valueExpression, Type valueType, ITypeConverter typeConverter) { if (valueType == null) throw new ArgumentNullException("valueType"); if (typeConverter == null) throw new ArgumentNullException("typeConverter"); _valueExpression = valueExpression; _valueType = valueType; _typeConverter = typeConverter; }
public IMappingBuilder <TSource, TDest> ForMember <TProp>(Expression <Func <TDest, TProp> > destProp, Expression <Func <TSource, TProp> > sourceProp) { EnsureIsMemberExpression(destProp.Body); EnsureIsMemberExpression(sourceProp.Body); MappingExpression <TSource, TDest> .ReplaceMappingSource( (MemberExpression)destProp.Body, (MemberExpression)sourceProp.Body); return(this); }
/// <summary> /// Creates a new mapper with the specified mapper and default metadata with the permitInheritance flag /// </summary> /// <typeparam name="TS"></typeparam> /// <typeparam name="TT"></typeparam> /// <param name="engine"></param> /// <param name="mapper"></param> /// <param name="permitInheritance"></param> /// <returns></returns> public static IMappingExpression <TS, TT> CreateMap <TS, TT>(this AbstractFluentMappingEngine engine, ITypeMapper <TS, TT> mapper, bool permitInheritance) { var metadata = new TypeMapperMetadata(typeof(TS), typeof(TT), permitInheritance); engine.AddMap(mapper, metadata); //create enumerable type map for the types automatically if they aren't already IEnumerable engine.CreateEnumerableMap <TS, TT>(); var expression = new MappingExpression <TS, TT>(mapper.MappingContext); return(expression); }
/// <summary> /// Initializes a new instance of the <see cref="ArrayValueCalculator"/> class. /// </summary> /// <param name="elementType"> /// The element type. /// </param> /// <param name="valueExpression"> /// The value expression. /// </param> /// <param name="elementCalculator"> /// The element calculator. /// </param> /// <param name="typeConverter"> /// The type converter. /// </param> public ArrayValueCalculator(Type elementType, MappingExpression valueExpression, IValueCalculator elementCalculator, ITypeConverter typeConverter) { if (elementType == null) throw new ArgumentNullException("elementType"); if (typeConverter == null) throw new ArgumentNullException("typeConverter"); _typeConverter = typeConverter; _elementType = elementType; _valueExpression = valueExpression; _elementCalculator = elementCalculator; }
public IMappingExpression CreateMap(Type sourceType, Type destinationType, MemberList memberList) { var map = new MappingExpression(new TypePair(sourceType, destinationType), memberList); _typeMapConfigs.Add(map); if (sourceType.IsGenericTypeDefinition() || destinationType.IsGenericTypeDefinition()) { _openTypeMapConfigs.Add(map); } return(map); }
public TypeMap CreateConventionTypeMap(TypePair types, IConfigurationProvider configurationProvider) { var typeMap = _typeMapFactory.CreateTypeMap(types.SourceType, types.DestinationType, this); typeMap.IsConventionMap = true; var config = new MappingExpression(typeMap.Types, typeMap.ConfiguredMemberList); config.Configure(typeMap); Configure(typeMap, configurationProvider); return(typeMap); }
public IMappingBuilder <TSource, TDest> ForMember <TProp>(Expression <Func <TDest, TProp> > destProp, Action <MappingOptions> optionsSetup) { EnsureIsMemberExpression(destProp.Body); var options = new MappingOptions(); optionsSetup(options); if (options.IsPropIgnored) { MappingExpression <TSource, TDest> .RemoveMapping((MemberExpression)destProp.Body); } return(this); }
/// <summary> /// Initializes a new instance of the <see cref="SampleFieldMapping"/> class. /// </summary> /// <param name="property"> /// The property. /// </param> /// <param name="valueExpression"> /// The value expression. /// </param> /// <param name="childMappings"> /// The child mappings. /// </param> public SampleFieldMapping( PropertyInfo property, MappingExpression valueExpression, IEnumerable<ISampleValueMapping> childMappings) { if (property == null) throw new ArgumentNullException("property"); if (childMappings == null) throw new ArgumentNullException("childMappings"); _property = property; _valueExpression = valueExpression; _childMappings = childMappings.ToArray(); }
public void MinValue_greater_Value_Returns_True() { // arrange var model = new Model2 { Number = 11 }; var expression = new MappingExpression <Model2>(); expression.ForMember(m => m.Number, (n, exp) => exp.MinValue(n, 10, null)); // act var result = expression.Validate(model, _settings); // assert result.Success.Should().BeTrue(); }
TypeMap IProfileConfiguration.ConfigureConventionTypeMap(TypeMapRegistry typeMapRegistry, TypePair types) { if (!TypeConfigurations.Any(c => c.IsMatch(types))) { return(null); } var typeMap = _typeMapFactory.CreateTypeMap(types.SourceType, types.DestinationType, this, MemberList.Destination); var config = new MappingExpression(typeMap.TypePair, typeMap.ConfiguredMemberList); config.Configure(this, typeMap); Configure(typeMapRegistry, typeMap); return(typeMap); }
public void IsEmailAddress_With_Valid_Email_Return_True() { var model = new ModelSimple { Name = "*****@*****.**" }; var expression = new MappingExpression <ModelSimple>(); expression .ForMember(m => m.Name, (n, exp) => exp.IsEmailAddress(n, "{0} != email '{1}'")); // act var result = expression.Validate(model, _settings); // assert result.Success.Should().BeTrue(); }
/// <summary> /// Initializes a new instance of the <see cref="SampleValueMapping"/> class. /// </summary> /// <param name="property"> /// The property. /// </param> /// <param name="valueExpression"> /// The value expression. /// </param> /// <param name="isKey"> /// The is key. /// </param> /// <param name="typeConverter"> /// The type converter. /// </param> public SampleValueMapping(PropertyInfo property, MappingExpression valueExpression, bool isKey, ITypeConverter typeConverter) { if (property == null) throw new ArgumentNullException("property"); if (valueExpression == null) throw new ArgumentNullException("valueExpression"); if (typeConverter == null) throw new ArgumentNullException("typeConverter"); _typeConverter = typeConverter; _property = property; _isKey = isKey; _valueExpression = valueExpression; }
public void NotNullOrEmpty_NonEmpty_String_Is_Valid() { // arrange var model = new ModelSimple { Name = "a" }; var expression = new MappingExpression <ModelSimple>(); expression .ForMember(m => m.Name, (n, exp) => exp.NotNullOrEmpty(n, null)); // act var result = expression.Validate(model, _settings); // assert result.Success.Should().BeTrue(); }
public void MinLength_Validator_ExpressionGreaterValue_is_valid() { // arrange var model = new ModelSimple { Name = "123", }; var expression = new MappingExpression <ModelSimple>(); expression .ForMember(m => m.Name, (n, exp) => exp.MinLength(n, 2, null)); // act var result = expression.Validate(model, _settings); // assert result.Success.Should().BeTrue(); }
public void NotNullOrEmpty_Empty_String_Is_Not_Valid_Override_Message() { // arrange var model = new ModelSimple(); var expression = new MappingExpression <ModelSimple>(); expression .ForMember(m => m.Name, (n, exp) => exp.NotNullOrEmpty(n, "Test {0} Test")); // act var result = expression.Validate(model, _settings); // assert result.Errors.Should().ContainKey("Name"); var nameErrors = result.Errors["Name"]; nameErrors.Count.Should().Be(1); nameErrors.Should().Contain(e => e == "Test Name Test"); }
public void MinValue_Too_small_Value_Returns_False_custom_error() { // arrange var model = new Model2 { Number = 10 }; var expression = new MappingExpression <Model2>(); expression.ForMember(m => m.Number, (n, exp) => exp.MinValue(n, 11, "Test {0} should be more than {1} {2}")); // act var result = expression.Validate(model, _settings); // assert result.Success.Should().BeFalse(); result.Errors.Should().ContainKey("Number"); var nameErrors = result.Errors["Number"]; nameErrors.Count.Should().Be(1); nameErrors.Should().Contain(e => e == "Test 11 should be more than Number 10"); }
public void MinValue_Too_small_Value_Returns_False() { // arrange var model = new Model2 { Number = 10 }; var expression = new MappingExpression <Model2>(); expression.ForMember(m => m.Number, (n, exp) => exp.MinValue(n, 11, null)); // act var result = expression.Validate(model, _settings); // assert result.Success.Should().BeFalse(); result.Errors.Should().ContainKey("Number"); var errors = result.Errors["Number"]; errors.Count.Should().Be(1); errors.Should().Contain(e => e == "Number should be at least 11"); }
public void MaxLength_Validator_Equal_Length_Expression_valid() { // arrange // arrange var model = new ModelSimple { Name = "123", }; var expression = new MappingExpression <ModelSimple>(); expression .ForMember(m => m.Name, (n, exp) => exp.MaxLength(n, 3, null)); // act var result = expression.Validate(model, _settings); // assert result.Success.Should().BeTrue(); result.Errors.Count.Should().Be(0); }
/// <summary> /// Initializes a new instance of the <see cref="SimpleFieldMapping"/> class. /// </summary> /// <param name="property"> /// The property. /// </param> /// <param name="valueExpression"> /// The value expression. /// </param> /// <param name="isKey"> /// Specifies whether this is a key mapping. /// </param> /// <param name="typeConverter"> /// The type converter. /// </param> public SimpleFieldMapping(PropertyInfo property, MappingExpression valueExpression, bool isKey, ITypeConverter typeConverter) { if (property == null) throw new ArgumentNullException("property"); if (valueExpression == null) throw new ArgumentNullException("valueExpression"); if (typeConverter == null) throw new ArgumentNullException("typeConverter"); _typeConverter = typeConverter; _property = property; _valueExpression = valueExpression; _isKey = isKey; _allowLocalizedData = Property.GetCustomAttribute<AllowLocalizedDataAttribute>() != null; if (AllowLocalizedData) { _supportedLocalizations = new List<ILocalizationInfo>(Property.DeclaringType.GetCustomAttributes<LocalizationInfoAttribute>()); } }
public void IsEmailAddress_Invalid_Email_Error_Custom_Error() { // arrange var model = new ModelSimple { Name = "a.com" }; var expression = new MappingExpression <ModelSimple>(); expression .ForMember(m => m.Name, (n, exp) => exp.IsEmailAddress(n, "{0} != email '{1}'")); // act var result = expression.Validate(model, _settings); // assert result.Success.Should().BeFalse(); result.Errors.Should().ContainKey("Name"); var nameErrors = result.Errors["Name"]; nameErrors.Count.Should().Be(1); nameErrors.Should().Contain(e => e == "Name != email 'a.com'"); }
public void MinLength_Validator_Expression_Invalid_custom_error() { // arrange var model = new ModelSimple { Name = "Jon Hawkins", }; var expression = new MappingExpression <ModelSimple>(); expression .ForMember(m => m.Name, (n, exp) => exp.MinLength(n, 4444, "{0} - {1} - {2}")); // act var result = expression.Validate(model, _settings); // assert result.Errors.Should().ContainKey("Name"); var nameErrors = result.Errors["Name"]; nameErrors.Count.Should().Be(1); nameErrors.Should().Contain(e => e == "4444 - Name - Jon Hawkins"); }
public void MaxLength_Validator_Expression_Invalid() { // arrange // arrange var model = new ModelSimple { Name = "Jon Hawkins", }; var expression = new MappingExpression <ModelSimple>(); expression .ForMember(m => m.Name, (n, exp) => exp.MaxLength(n, 3, null)); // act var result = expression.Validate(model, _settings); // assert result.Errors.Should().ContainKey("Name"); var nameErrors = result.Errors["Name"]; nameErrors.Count.Should().Be(1); nameErrors.Should().Contain(e => e == "Name should not be longer than 3"); }
private void Configure(TypeMapRegistry typeMapRegistry, TypeMap typeMap) { foreach (var action in AllTypeMapActions) { var expression = new MappingExpression(typeMap.Types, typeMap.ConfiguredMemberList); action(typeMap, expression); expression.Configure(typeMap); } foreach (var action in AllPropertyMapActions) { foreach (var propertyMap in typeMap.GetPropertyMaps()) { var memberExpression = new MappingExpression.MemberConfigurationExpression(propertyMap.DestinationProperty, typeMap.SourceType); action(propertyMap, memberExpression); memberExpression.Configure(typeMap); } } ApplyBaseMaps(typeMapRegistry, typeMap, typeMap); ApplyDerivedMaps(typeMapRegistry, typeMap, typeMap); }
private void Seal(IConfiguration configuration) { ServiceCtor = configuration.ServiceCtor; AllowNullDestinationValues = configuration.AllowNullDestinationValues; AllowNullCollections = configuration.AllowNullCollections; var derivedMaps = new List <Tuple <TypePair, TypeMap> >(); var redirectedTypes = new List <Tuple <TypePair, TypePair> >(); foreach (var profile in configuration.Profiles.Cast <IProfileConfiguration>()) { profile.Register(TypeMapRegistry); } foreach (var action in configuration.AllTypeMapActions) { foreach (var typeMap in TypeMapRegistry.TypeMaps) { var expression = new MappingExpression(typeMap.TypePair, typeMap.ConfiguredMemberList); action(typeMap, expression); expression.Configure(typeMap.Profile, typeMap); } } foreach (var action in configuration.AllPropertyMapActions) { foreach (var typeMap in TypeMapRegistry.TypeMaps) { foreach (var propertyMap in typeMap.GetPropertyMaps()) { var memberExpression = new MappingExpression.MemberConfigurationExpression(propertyMap.DestMember, typeMap.SourceType); action(propertyMap, memberExpression); memberExpression.Configure(typeMap); } } } foreach (var profile in configuration.Profiles.Cast <IProfileConfiguration>()) { profile.Configure(TypeMapRegistry); } foreach (var typeMap in TypeMapRegistry.TypeMaps) { _typeMapPlanCache[typeMap.TypePair] = typeMap; if (typeMap.DestinationTypeOverride != null) { redirectedTypes.Add(Tuple.Create(typeMap.TypePair, new TypePair(typeMap.SourceType, typeMap.DestinationTypeOverride))); } if (typeMap.SourceType.IsNullableType()) { var nonNullableTypes = new TypePair(Nullable.GetUnderlyingType(typeMap.SourceType), typeMap.DestinationType); redirectedTypes.Add(Tuple.Create(nonNullableTypes, typeMap.TypePair)); } derivedMaps.AddRange(GetDerivedTypeMaps(typeMap).Select(derivedMap => Tuple.Create(new TypePair(derivedMap.SourceType, typeMap.DestinationType), derivedMap))); } foreach (var redirectedType in redirectedTypes) { var derivedMap = FindTypeMapFor(redirectedType.Item2); if (derivedMap != null) { _typeMapPlanCache[redirectedType.Item1] = derivedMap; } } foreach (var derivedMap in derivedMaps.Where(derivedMap => !_typeMapPlanCache.ContainsKey(derivedMap.Item1))) { _typeMapPlanCache[derivedMap.Item1] = derivedMap.Item2; } foreach (var typeMap in TypeMapRegistry.TypeMaps) { typeMap.Seal(TypeMapRegistry, this); } }
private IMappingExpression CreateMappingExpression(TypeMap typeMap, Type destinationType) { var mappingExp = new MappingExpression(typeMap, ServiceCtor, this); return((IMappingExpression)Ignore(mappingExp, destinationType)); }
public MappingBuilder() { MappingExpression <TSource, TDest> .Create(); }
public TypeMap ConfigureConventionTypeMap(TypeMapRegistry typeMapRegistry, TypePair types) { if (!TypeConfigurations.Any(c => c.IsMatch(types))) return null; var typeMap = _typeMapFactory.CreateTypeMap(types.SourceType, types.DestinationType, this, MemberList.Destination); var config = new MappingExpression(typeMap.Types, typeMap.ConfiguredMemberList); config.Configure(typeMap); Configure(typeMapRegistry, typeMap); return typeMap; }
private static MappingInfo GetMappingInfo(SpreadsheetDocument doc, IEnumerable <EvaluationSource> externalSources) { var templateFieldExpressions = new List <MappingExpression>(); var worksheet = GetFirstWorkSheet(doc); var stringTablePart = GetOrCreatePart <SharedStringTablePart>(doc); var stylesPart = GetOrCreatePart <WorkbookStylesPart>(doc); var rowIndex = 3U; string name; do { name = GetCellValue(GetCell(worksheet, $"A{rowIndex}"), stringTablePart); if (!string.IsNullOrEmpty(name)) { var formulaCell = GetCell(worksheet, $"F{rowIndex}"); var formulaCellFormat = GetCellFormat(formulaCell, stylesPart); var templateFieldExpression = new MappingExpression() { Name = name, Parent = GetCellValue(GetCell(worksheet, $"B{rowIndex}"), stringTablePart), IsCollection = GetCellValueAsBoolean(GetCell(worksheet, $"C{rowIndex}"), stringTablePart), Content = GetCellValue(GetCell(worksheet, $"D{rowIndex}"), stringTablePart), Expression = GetCellFormula(formulaCell), Cell = $"F{rowIndex}", NumFormatId = formulaCellFormat.Item1, NumFormatCode = formulaCellFormat.Item2 }; templateFieldExpressions.Add(templateFieldExpression); ++rowIndex; } } while (!string.IsNullOrEmpty(name)); templateFieldExpressions = ReorderExpressionsWithCalcChain(doc.WorkbookPart, templateFieldExpressions); var sources = new List <EvaluationSource>(); if (externalSources != null) { sources.AddRange(externalSources); } rowIndex = 3U; do { name = GetCellValue(GetCell(worksheet, $"M{rowIndex}"), stringTablePart); if (!string.IsNullOrEmpty(name)) { var existing = sources.FirstOrDefault(o => string.Equals(name, o.Name, StringComparison.InvariantCultureIgnoreCase)); if (existing != null) { existing.Cell = $"N{rowIndex}"; } else { var payload = GetCellValue(GetCell(worksheet, $"N{rowIndex}"), stringTablePart); sources.Add(new EvaluationSource() { Name = name, Cell = $"N{rowIndex}", Payload = JObject.Parse(payload) }); } ++rowIndex; } } while (!string.IsNullOrEmpty(name)); return(new MappingInfo() { Expressions = templateFieldExpressions, Sources = sources }); }