Beispiel #1
0
 public void Build(IModelMapperInternal modelMapper)
 {
     if (_queryFilter != null)
     {
         modelMapper.SetQueryFilter(_tableName, _queryFilter);
     }
 }
Beispiel #2
0
 /// <summary>
 /// Builds model configuration.
 /// </summary>
 /// <param name="modelMapper">Model mapper.</param>
 internal void Build(IModelMapperInternal modelMapper)
 {
     foreach (EntityTypeBuilderBase entityBuilder in _entityBuilders.Values)
     {
         entityBuilder.Build(modelMapper);
     }
 }
        internal override void Build(IModelMapperInternal modelMapper)
        {
            if (!_tableName.IsNullOrWhiteSpace())
            {
                modelMapper.SetTableName <TEntity>(_tableName);
            }
            if (!_primaryKeyPropertyName.IsNullOrWhiteSpace())
            {
                modelMapper.SetPrimaryKey <TEntity>(_primaryKeyPropertyName, _autoIncrementType);
            }
            foreach (KeyValuePair <Type, IConverter> item in _propertyConverters)
            {
                modelMapper.SetConverterForProperties <TEntity>(item.Key, item.Value);
            }

            var injectionConfig = new Lazy <InjectionConfiguration <TEntity> >(() => new InjectionConfiguration <TEntity>());

            foreach (PropertyBuilder <TEntity> propertyBuilder in _propertyBuilders.Values)
            {
                if (propertyBuilder.IsMapped)
                {
                    if (!propertyBuilder.ColumnName.IsNullOrWhiteSpace())
                    {
                        modelMapper.SetColumnName <TEntity>(propertyBuilder.PropertyName, propertyBuilder.ColumnName);
                    }
                    if (propertyBuilder.IgnoreConverter)
                    {
                        modelMapper.SetConverter <TEntity>(propertyBuilder.PropertyName, NoConverter.Instance);
                    }
                    else if (propertyBuilder.Converter != null)
                    {
                        modelMapper.SetConverter <TEntity>(propertyBuilder.PropertyName, propertyBuilder.Converter);
                    }
                    if (propertyBuilder.ValueGenerator != null)
                    {
                        modelMapper.SetValueGenerator <TEntity>(
                            propertyBuilder.PropertyName, propertyBuilder.ValueGenerator, propertyBuilder.ValueGenerated);
                    }
                    if (propertyBuilder.Injector != null)
                    {
                        injectionConfig.Value.FillProperty(propertyBuilder.PropertyName, propertyBuilder.Injector);
                    }
                }
                else
                {
                    modelMapper.SetNoMap <TEntity>(propertyBuilder.PropertyName);
                }
            }
            if (injectionConfig.IsValueCreated)
            {
                modelMapper.SetInjector <TEntity>(injectionConfig.Value);
            }
        }
        /// <summary>
        /// Builds model configuration.
        /// </summary>
        /// <param name="modelMapper">Model mapper.</param>
        internal void Build(IModelMapperInternal modelMapper)
        {
            modelMapper.UseIdentifierDelimiters(_delimiters);
            foreach (EntityTypeBuilderBase entityBuilder in _entityBuilders.Values)
            {
                entityBuilder.Build(modelMapper);
            }

            foreach (TableBuilder tableBuilder in _tableBuilders.Values)
            {
                tableBuilder.Build(modelMapper);
            }
        }
 /// <summary>
 /// Builds entity configuration.
 /// </summary>
 /// <param name="modelMapper">Model mappper.</param>
 internal abstract void Build(IModelMapperInternal modelMapper);