/// <inheritdoc />
public override void OnModelCreating(ModelConfigurationBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Workshop>()
.HasTableName(WorkshopsTableName)
.HasPrimaryKey(f => f.Id).AutoIncrement()
.UseConverterForProperties <string>(NullAndTrimStringConverter.ConvertNull)
.Property(f => f.CreatedTimestamp).UseCurrentTimeValueGenerator(ValueGenerated.OnInsert)
.Property(f => f.LastModifiedTimestamp).UseCurrentTimeValueGenerator(ValueGenerated.OnInsertOrUpdate)
.Property(f => f.CreatedBy).UseValueGeneratorOnInsert(new CurrentUserValueGenerator(ServiceProvider))
.Property(f => f.LastModifiedBy).UseValueGeneratorOnInsertOrUpdate(new CurrentUserValueGenerator(ServiceProvider));
modelBuilder.Entity <Person>()
.HasTableName(PeopleTableName)
.HasPrimaryKey(f => f.Id).AutoIncrement()
.UseConverterForProperties <string>(NullAndTrimStringConverter.ConvertNull)
.Property(f => f.CreatedTimestamp).UseCurrentTimeValueGenerator(ValueGenerated.OnInsert)
.Property(f => f.LastModifiedTimestamp).UseCurrentTimeValueGenerator(ValueGenerated.OnInsertOrUpdate)
.Property(f => f.CreatedBy).UseValueGeneratorOnInsert(new CurrentUserValueGenerator(ServiceProvider))
.Property(f => f.LastModifiedBy).UseValueGeneratorOnInsertOrUpdate(new CurrentUserValueGenerator(ServiceProvider));
modelBuilder.Entity <Attendance>()
.HasTableName(AttendanceTableName)
.HasPrimaryKey(f => f.Id).AutoIncrement();
}
public override void OnModelCreating(ModelConfigurationBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Table("Foo")
.UseQueryFilter <Foo>(f => f.UserId == 1);
}
protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
configurationBuilder
.Properties <NonEmptyString>()
.HaveMaxLength(250)
.HaveConversion <NonEmptyStringValueConverter>();
}
public override void OnModelCreating(ModelConfigurationBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Photo>()
.HasTableName("Photos")
.HasPrimaryKey(p => p.Id).AutoIncrement();
}
public override void OnModelCreating(ModelConfigurationBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Product>()
.HasTableName("Products")
.HasPrimaryKey(p => p.Id).AutoIncrement(AutoIncrementMethodType.Identity);
}
protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
configurationBuilder
.Properties <LaunchRecordId>()
.HaveConversion <LaunchRecordId.EfCoreValueConverter>();
configurationBuilder
.Properties <RocketId>()
.HaveConversion <RocketId.EfCoreValueConverter>();
}
/// <summary>
/// Create database model.
/// </summary>
/// <param name="modelBuilder"><see cref="ModelConfigurationBuilder"/></param>
public override void OnModelCreating(ModelConfigurationBuilder modelBuilder)
{
modelBuilder.Entity <RRREntityNameRRR_>()
.HasTableName(RRREntityNameRRR_Plural_TableName)
.HasPrimaryKey(f => f.Id).AutoIncrement()
.UseConverterForProperties <string>(NullAndTrimStringConverter.ConvertNull)
.Property(f => f.CreatedTimestamp).UseCurrentTimeValueGenerator(ValueGenerated.OnInsert)
.Property(f => f.LastModifiedTimestamp).UseCurrentTimeValueGenerator(ValueGenerated.OnInsertOrUpdate);
}
public override void OnModelCreating(ModelConfigurationBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Order>()
.HasTableName("Orders")
.HasPrimaryKey(p => p.Id).AutoIncrement(AutoIncrementMethodType.Identity)
.Property(p => p.Items).UseConverter <JsonConverter <List <OrderItem> > >();
}
public override void OnModelCreating(ModelConfigurationBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Bar>()
.HasTableName("Foo")
.HasPrimaryKey(p => p.RowId)
.Property(p => p.RowId).HasColumnName("Id")
.Property(p => p.Age).HasColumnName("Value");
}
public static ModelConfigurationBuilder AddStronglyTypedIds(
this ModelConfigurationBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Properties <EnrollmentId>()
.HaveConversion(typeof(EnrollmentIdValueConverter), null);
return(builder);
}
public void ThrowExceptionWhenMappingTheTheSamePropertyMoreThanOnce()
{
Action builderAction = () =>
{
var modelBuilder = new ModelConfigurationBuilder();
modelBuilder.Entity <ConvertersEntity>()
.Property(p => p.StringProp1).UseConverter <StringConverter2>()
.Property(p => p.StringProp1).IgnoreConverter();
};
builderAction.Should().Throw <InvalidOperationException>();
}
public void ThrowExceptionWhenUseCurrentTimeGeneratorOnNever()
{
var modelBuilder = new ModelConfigurationBuilder();
var modelMapper = new ConventionModelMapper();
Action act = () =>
modelBuilder.Entity <BuilderTestEntity>()
.Property(p => p.GeneratedValue)
.UseCurrentTimeValueGenerator(ValueGenerated.Never);
act.Should().Throw <NotSupportedException>();
}
protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
base.ConfigureConventions(configurationBuilder);
configurationBuilder.Properties <string>()
//.AreUnicode(false)
//.AreFixedLength()
.HaveMaxLength(255);
configurationBuilder.Properties <decimal>()
.HavePrecision(5, 2);
}
private ConventionModelMapper CreateModelMapper()
{
var modelMapper = new ConventionModelMapper();
if (_databaseConfiguration != null)
{
var modelBuilder = new ModelConfigurationBuilder();
_databaseConfiguration.OnModelCreating(modelBuilder);
modelBuilder.Build(modelMapper);
}
return(modelMapper);
}
public void UseEmptyQuota()
{
var modelBuilder = new ModelConfigurationBuilder();
var modelMapper = new ConventionModelMapper();
modelBuilder.Entity <BuilderTestEntity>()
.HasTableName("BuilderTest");
modelBuilder.Build(modelMapper);
TableInfo tableInfo = modelMapper.GetTableInfo <BuilderTestEntity>();
tableInfo.Delimiters.Should().Be(Delimiters.Empty);
}
public void SetNamingQuota()
{
var modelBuilder = new ModelConfigurationBuilder();
var modelMapper = new ConventionModelMapper();
modelBuilder.UseIdentifierDelimiters(Delimiters.SquareBrackets);
modelBuilder.Entity <BuilderTestEntity>()
.HasTableName("BuilderTest");
modelBuilder.Build(modelMapper);
TableInfo tableInfo = modelMapper.GetTableInfo <BuilderTestEntity>();
tableInfo.Delimiters.Should().Be(Delimiters.SquareBrackets);
}
public void UseCurrentTimeGeneratorOnInsert()
{
var modelBuilder = new ModelConfigurationBuilder();
var modelMapper = new ConventionModelMapper();
modelBuilder.Entity <BuilderTestEntity>()
.Property(p => p.GeneratedValue).UseCurrentTimeValueGenerator(ValueGenerated.OnInsert);
modelBuilder.Build(modelMapper);
TableInfo tableInfo = modelMapper.GetTableInfo <BuilderTestEntity>();
tableInfo.GetColumnInfoByPropertyName("GeneratedValue").ValueGenerated.Should().Be(ValueGenerated.OnInsert);
tableInfo.GetColumnInfoByPropertyName("GeneratedValue").ValueGenerator.Should().BeOfType <CurrentTimeValueGenerator>();
}
public void DoNotReturnQueryFilterIfWasNotConfigured()
{
var modelBuilder = new ModelConfigurationBuilder();
var modelMapper = new ConventionModelMapper();
modelBuilder.Entity <FooQueryFilter>()
.HasTableName("Foo");
modelBuilder.Build(modelMapper);
TableInfo tableInfo = modelMapper.GetTableInfo <FooQueryFilter>();
tableInfo.QueryFilter
.Should().BeNull();
}
public void BuildConfiguration()
{
var modelBuilder = new ModelConfigurationBuilder();
var modelMapper = new ConventionModelMapper();
modelBuilder.Entity <BuilderTestEntity>()
.HasTableName("BuilderTest")
.HasPrimaryKey(f => f.Id).AutoIncrement(AutoIncrementMethodType.Custom)
.Property(p => p.Address)
.HasColumnName("COL_ADDRESS")
.UseConverter <AddressConverter>()
.Property(p => p.NoMapped).NoMap()
.Property(p => p.FirstName).HasColumnName("Name")
.Property(p => p.DateTime).InjectValue(() => DateTime.Now)
.Property(p => p.GeneratedValue).UseValueGeneratorOnInsert <AutoIncrementValueGenerator>();
modelBuilder.Build(modelMapper);
TableInfo tableInfo = modelMapper.GetTableInfo <BuilderTestEntity>();
var columns = new List <ColumnInfo>()
{
new ColumnInfo()
{
Name = "Id",
IsPrimaryKey = true,
AutoIncrementMethodType = AutoIncrementMethodType.Custom
},
new ColumnInfo()
{
Name = "COL_ADDRESS", Converter = new AddressConverter()
},
new ColumnInfo()
{
Name = "Name"
},
new ColumnInfo()
{
Name = "GeneratedValue", ValueGenerator = new AutoIncrementValueGenerator()
}
};
TableInfo tableInfoExpected = CreateExpectedTableInfo(columns, "BuilderTest");
AreSame(tableInfo, tableInfoExpected);
modelMapper.GetInjector <BuilderTestEntity>().IsInjectable("DateTime")
.Should()
.BeTrue("DateTime property has injector.");
}
protected override IModel CreateModel(
DbContext context,
IConventionSetBuilder conventionSetBuilder,
ModelDependencies modelDependencies)
{
var modelConfigurationBuilder = new ModelConfigurationBuilder(conventionSetBuilder.CreateConventionSet());
_configureConventions?.Invoke(modelConfigurationBuilder);
var modelBuilder = modelConfigurationBuilder.CreateModelBuilder(modelDependencies);
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
_onModelCreating(modelBuilder, context);
return(modelBuilder.FinalizeModel());
}
public void ThrowExceptionWhenTryConfigureQueryFilterMoreTimesForOneTable()
{
var modelBuilder = new ModelConfigurationBuilder();
var modelMapper = new ConventionModelMapper();
modelBuilder.Table("Foo")
.UseQueryFilter <FooQueryFilter>(f => f.AutorId == 5);
Action action = ()
=> modelBuilder.Table("Foo")
.UseQueryFilter <FooQueryFilter>(f => f.Id > 2);
action
.Should()
.Throw <InvalidOperationException>()
.WithMessage("*Foo*");
}
public void UseQueryFilter()
{
var modelBuilder = new ModelConfigurationBuilder();
var modelMapper = new ConventionModelMapper();
modelBuilder.Entity <FooQueryFilter>()
.HasTableName("Foo");
modelBuilder.Table("Foo")
.UseQueryFilter <FooQueryFilter>(f => f.AutorId == 5);
modelBuilder.Build(modelMapper);
TableInfo tableInfo = modelMapper.GetTableInfo <FooQueryFilter>();
tableInfo.QueryFilter
.Should().NotBeNull();
}
protected override void ConfigureConventions(ModelConfigurationBuilder builder)
{
builder.Properties <DateOnly>()
.HaveConversion <DateOnlyConverter>()
.HaveColumnType("date");
builder.Properties <TimeOnly>()
.HaveConversion <TimeOnlyConverter>()
.HaveColumnType("date");
builder.Properties <DateOnly?>()
.HaveConversion <NullableDateOnlyConverter>()
.HaveColumnType("date");
builder.Properties <TimeOnly?>()
.HaveConversion <NullableTimeOnlyConverter>()
.HaveColumnType("date");
}
public void UseConverterForAllPropertiesOfSpecifiedType()
{
var modelBuilder = new ModelConfigurationBuilder();
var modelMapper = new ConventionModelMapper();
modelBuilder.Entity <ConvertersEntity>()
.UseConverterForProperties <int>(new IntConverter())
.UseConverterForProperties <string, StringConverter1>()
.Property(p => p.StringPropWithOwnConverter).UseConverter <StringConverter2>()
.Property(p => p.StringPropWithoutConverter).IgnoreConverter();
modelBuilder.Build(modelMapper);
TableInfo tableInfo = modelMapper.GetTableInfo <ConvertersEntity>();
ColumnInfo intProp1 = tableInfo.GetColumnInfo(nameof(ConvertersEntity.IntProp1));
ColumnInfo intProp2 = tableInfo.GetColumnInfo(nameof(ConvertersEntity.IntProp1));
intProp1.Converter
.Should().BeOfType <IntConverter>()
.And.Be(intProp2.Converter);
ColumnInfo stringProp1 = tableInfo.GetColumnInfo(nameof(ConvertersEntity.StringProp1));
ColumnInfo stringProp2 = tableInfo.GetColumnInfo(nameof(ConvertersEntity.StringProp2));
ColumnInfo stringProp3 = tableInfo.GetColumnInfo(nameof(ConvertersEntity.StringProp3));
ColumnInfo stringProp4 = tableInfo.GetColumnInfo(nameof(ConvertersEntity.StringProp4));
stringProp1.Converter
.Should().BeOfType <StringConverter1>()
.And.Be(stringProp2.Converter)
.And.Be(stringProp3.Converter)
.And.Be(stringProp4.Converter);
ColumnInfo stringPropWithOwnConverter = tableInfo.GetColumnInfo(nameof(ConvertersEntity.StringPropWithOwnConverter));
stringPropWithOwnConverter.Converter.Should().BeOfType <StringConverter2>();
ColumnInfo stringPropWithoutConverter = tableInfo.GetColumnInfo(nameof(ConvertersEntity.StringPropWithoutConverter));
stringPropWithoutConverter.Converter.Should().BeNull();
tableInfo.GetColumnInfo(nameof(ConvertersEntity.BoolProp)).Converter.Should().BeNull();
tableInfo.GetColumnInfo(nameof(ConvertersEntity.DateTimeProp)).Converter.Should().BeNull();
}
public void BuildConfigurationWhenRenamePropertyForPrimaryKey()
{
var modelBuilder = new ModelConfigurationBuilder();
var modelMapper = new ConventionModelMapper();
modelBuilder.Entity <Foo>()
.HasTableName("FooTable")
.HasPrimaryKey(f => f.FooId).AutoIncrement()
.Property(p => p.FooId).HasColumnName("RowId");
modelBuilder.Build(modelMapper);
TableInfo tableInfo = modelMapper.GetTableInfo <Foo>();
var columns = new List <ColumnInfo>()
{
new ColumnInfo()
{
Name = "RowId",
IsPrimaryKey = true,
AutoIncrementMethodType = AutoIncrementMethodType.Identity
},
new ColumnInfo()
{
Name = "Addresses"
},
new ColumnInfo()
{
Name = "FirstName"
},
new ColumnInfo()
{
Name = "NoMapped"
},
new ColumnInfo()
{
Name = "DateTime"
}
};
TableInfo tableInfoExpected = CreateExpectedTableInfo(columns, "FooTable");
AreSame(tableInfo, tableInfoExpected);
}
public void BuildConfigurationWhenAutoIncrementMethodTypeIsNotSet()
{
var modelBuilder = new ModelConfigurationBuilder();
var modelMapper = new ConventionModelMapper();
modelBuilder.Entity <Foo>()
.HasPrimaryKey(f => f.FooId);
modelBuilder.Build(modelMapper);
TableInfo tableInfo = modelMapper.GetTableInfo <Foo>();
var columns = new List <ColumnInfo>()
{
new ColumnInfo()
{
Name = "FooId",
IsPrimaryKey = true,
AutoIncrementMethodType = AutoIncrementMethodType.None
},
new ColumnInfo()
{
Name = "Addresses"
},
new ColumnInfo()
{
Name = "FirstName"
},
new ColumnInfo()
{
Name = "NoMapped"
},
new ColumnInfo()
{
Name = "DateTime"
}
};
TableInfo tableInfoExpected = CreateExpectedTableInfo(columns, "Foo");
AreSame(tableInfo, tableInfoExpected);
}
public override void OnModelCreating(ModelConfigurationBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Table("Foo")
.UseQueryFilter <Foo>(f => f.Value > 2);
modelBuilder.Entity <Foo2>()
.HasTableName("Foo");
modelBuilder.Entity <Bar>()
.HasTableName("Bars");
modelBuilder.Table("Bars").UseQueryFilter <Bar>(b => b.Value.StartsWith("Slov"));
modelBuilder.Table("FooBar")
.UseQueryFilter <FooBar>(f => f.Value > GetValue());
modelBuilder.Table("ComplexCondition")
.UseQueryFilter <ComplexCondition>(f => (f.Value > 1 && f.Value < 1000) || f.Id > 0);
}
protected override void OnBuild(ModelConfigurationBuilder <TestEntity, TestModel> builder)
{
builder.EntityProperty(entity => entity.Id)
.HasModelProperty(model => model.Id);
builder.EntityProperty(entity => entity.Name)
.HasModelProperty(model => model.Name);
builder.EntityProperty(entity => entity.Email)
.HasModelProperty(model => model.Email);
builder.EntityProperty(entity => entity.Birthdate)
.HasModelProperty(model => model.Birthdate);
builder.ModelProperty(model => model.Age)
.ModelOnly()
.GetEntityValue(entity => new DateTime(DateTime.Today.Subtract(entity.Birthdate).Ticks).Year);
builder.ModelProperty(model => model.CreatedAt)
.HasEntityProperty(entity => entity.CreatedAt)
.IsModelOnly();
}
protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
configurationBuilder.Properties <DateTime>().HaveConversion <long>();
}
public override void OnModelCreating(ModelConfigurationBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.UseIdentifierDelimiters(_quota);
}
