/// <summary>
/// Generate entity type properties.
/// </summary>
/// <param name="entityType">Represents an entity type in an <see cref="T:Microsoft.EntityFrameworkCore.Metadata.IModel" />.</param>
protected virtual void GenerateProperties(IEntityType entityType)
{
if (entityType == null)
{
throw new ArgumentNullException(nameof(entityType));
}
var properties = new List <Dictionary <string, object> >();
foreach (var property in entityType.GetProperties().OrderBy(p => p.Scaffolding().ColumnOrdinal))
{
_propertyAnnotations = new List <Dictionary <string, object> >();
if (_useDataAnnotations)
{
GeneratePropertyDataAnnotations(property);
}
properties.Add(new Dictionary <string, object>
{
{ "property-type", CSharpUtilities.GetTypeName(property.ClrType) },
{ "property-name", property.Name },
{ "property-annotations", _propertyAnnotations }
});
}
_templateData.Add("properties", properties);
}
private void GenerateSequence(ISequence sequence, IndentedStringBuilder sb)
{
var methodName = nameof(RelationalModelBuilderExtensions.HasSequence);
if (sequence.ClrType != Sequence.DefaultClrType)
{
methodName += $"<{CSharpUtilities.GetTypeName(sequence.ClrType)}>";
}
var parameters = CSharpUtilities.DelimitString(sequence.Name);
if (string.IsNullOrEmpty(sequence.Schema) &&
sequence.Model.Relational().DefaultSchema != sequence.Schema)
{
parameters += $", {CSharpUtilities.DelimitString(sequence.Schema)}";
}
var lines = new List <string>
{
$"modelBuilder.{methodName}({parameters})"
};
if (sequence.StartValue != Sequence.DefaultStartValue)
{
lines.Add($".{nameof(SequenceBuilder.StartsAt)}({sequence.StartValue})");
}
if (sequence.IncrementBy != Sequence.DefaultIncrementBy)
{
lines.Add($".{nameof(SequenceBuilder.IncrementsBy)}({sequence.IncrementBy})");
}
if (sequence.MinValue != Sequence.DefaultMinValue)
{
lines.Add($".{nameof(SequenceBuilder.HasMin)}({sequence.MinValue})");
}
if (sequence.MaxValue != Sequence.DefaultMaxValue)
{
lines.Add($".{nameof(SequenceBuilder.HasMax)}({sequence.MaxValue})");
}
if (sequence.IsCyclic != Sequence.DefaultIsCyclic)
{
lines.Add($".{nameof(SequenceBuilder.IsCyclic)}()");
}
if (lines.Count == 2)
{
lines = new List <string>
{
lines[0] + lines[1]
};
}
sb.AppendLine();
sb.Append(lines[0]);
using (sb.Indent())
{
foreach (var line in lines.Skip(1))
{
sb.AppendLine();
sb.Append(line);
}
}
sb.AppendLine(";");
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual void AddSequenceConfigurations()
{
_sequenceConfigurations = new List <SequenceConfiguration>();
foreach (var sequence in AnnotationProvider.For(Model).Sequences)
{
var config = _configurationFactory.CreateSequenceConfiguration();
config.NameIdentifier = CSharpUtilities.DelimitString(sequence.Name);
if (sequence.ClrType != Sequence.DefaultClrType)
{
config.TypeIdentifier = CSharpUtilities.GetTypeName(sequence.ClrType);
}
if (!string.IsNullOrEmpty(sequence.Schema) &&
AnnotationProvider.For(Model).DefaultSchema != sequence.Schema)
{
config.SchemaNameIdentifier = CSharpUtilities.DelimitString(sequence.Schema);
}
if (sequence.StartValue != Sequence.DefaultStartValue)
{
config.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
false,
nameof(RelationalSequenceBuilder.StartsAt),
sequence.StartValue.ToString(CultureInfo.InvariantCulture)));
}
if (sequence.IncrementBy != Sequence.DefaultIncrementBy)
{
config.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
false,
nameof(RelationalSequenceBuilder.IncrementsBy),
sequence.IncrementBy.ToString(CultureInfo.InvariantCulture)));
}
if (sequence.MinValue != Sequence.DefaultMinValue)
{
config.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
false,
nameof(RelationalSequenceBuilder.HasMin),
sequence.MinValue?.ToString(CultureInfo.InvariantCulture) ?? ""));
}
if (sequence.MaxValue != Sequence.DefaultMaxValue)
{
config.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
false,
nameof(RelationalSequenceBuilder.HasMax),
sequence.MaxValue?.ToString(CultureInfo.InvariantCulture) ?? ""));
}
if (sequence.IsCyclic != Sequence.DefaultIsCyclic)
{
config.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
false,
nameof(RelationalSequenceBuilder.IsCyclic)));
}
_sequenceConfigurations.Add(config);
}
}
