private void GenerateColumnAttribute(IProperty property)
{
var columnName = property.GetColumnName();
var columnType = property.GetConfiguredColumnType();
var delimitedColumnName = columnName != null && columnName != property.Name ? CSharpHelper.Literal(columnName) : null;
var delimitedColumnType = columnType != null?CSharpHelper.Literal(columnType) : null;
if ((delimitedColumnName ?? delimitedColumnType) != null)
{
var columnAttribute = new AttributeWriter(nameof(ColumnAttribute));
if (delimitedColumnName != null)
{
columnAttribute.AddParameter(delimitedColumnName);
}
if (delimitedColumnType != null)
{
columnAttribute.AddParameter($"{nameof(ColumnAttribute.TypeName)} = {delimitedColumnType}");
}
PropertyAnnotationsData.Add(new Dictionary <string, object>
{
{ "property-annotation", columnAttribute },
});
}
}
private void GenerateTableName(IEntityType entityType, IndentedStringBuilder sb)
{
var tableName = entityType.Relational().TableName;
var schema = entityType.Relational().Schema;
var defaultSchema = entityType.Model.Relational().DefaultSchema;
var explicitSchema = schema != null && schema != defaultSchema;
var explicitTable = explicitSchema || tableName != null && tableName != entityType.Scaffolding().DbSetName;
if (explicitTable)
{
var parameterString = CSharpHelper.Literal(tableName);
if (explicitSchema)
{
parameterString += ", " + CSharpHelper.Literal(schema);
}
var lines = new List <string>
{
$".{nameof(RelationalEntityTypeBuilderExtensions.ToTable)}({parameterString})"
};
AppendMultiLineFluentApi(entityType, lines, sb);
}
}
private void GenerateInversePropertyAttribute(INavigation navigation)
{
if (navigation.ForeignKey.PrincipalKey.IsPrimaryKey())
{
var inverseNavigation = navigation.FindInverse();
if (inverseNavigation != null)
{
var inversePropertyAttribute = new AttributeWriter(nameof(InversePropertyAttribute));
var propertyName = EntityTypeTransformationService.TransformNavPropertyName(inverseNavigation.Name, navigation.DeclaringType.Name);
inversePropertyAttribute.AddParameter(
!navigation.DeclaringEntityType.GetPropertiesAndNavigations().Any(
m => m.Name == inverseNavigation.DeclaringEntityType.Name ||
EntityTypeTransformationService.TransformNavPropertyName(m.Name, navigation.GetTargetType().Name) == EntityTypeTransformationService.TransformNavPropertyName(inverseNavigation.DeclaringEntityType.Name, navigation.GetTargetType().Name))
? $"nameof({EntityTypeTransformationService.TransformEntityName(inverseNavigation.DeclaringType.Name)}.{propertyName})"
: CSharpHelper.Literal(propertyName));
NavPropertyAnnotations.Add(new Dictionary <string, object>
{
{ "nav-property-annotation", inversePropertyAttribute.ToString() },
});
}
}
}
private void GenerateTableName(IEntityType entityType, IndentedStringBuilder sb)
{
var tableName = entityType.GetTableName();
var schema = entityType.GetSchema();
var defaultSchema = entityType.Model.GetDefaultSchema();
var explicitSchema = schema != null && schema != defaultSchema;
var explicitTable = explicitSchema || tableName != null && tableName != entityType.GetDbSetName();
var isView = entityType.FindAnnotation(RelationalAnnotationNames2.ViewDefinition) != null;
if (explicitTable || isView)
{
var parameterString = CSharpHelper.Literal(tableName);
if (explicitSchema)
{
parameterString += ", " + CSharpHelper.Literal(schema);
}
var lines = new List <string>
{
$".{(isView ? nameof(RelationalEntityTypeBuilderExtensions.ToView) : nameof(RelationalEntityTypeBuilderExtensions.ToTable))}({parameterString})"
};
AppendMultiLineFluentApi(entityType, lines, sb);
}
}
private void GenerateTableAttribute(IEntityType entityType)
{
var tableName = entityType.GetTableName();
var schema = entityType.GetSchema();
var defaultSchema = entityType.Model.GetDefaultSchema();
var schemaParameterNeeded = schema != null && schema != defaultSchema;
var tableAttributeNeeded = schemaParameterNeeded || tableName != null && tableName != entityType.GetDbSetName();
if (tableAttributeNeeded)
{
var tableAttribute = new AttributeWriter(nameof(TableAttribute));
tableAttribute.AddParameter(CSharpHelper.Literal(tableName));
if (schemaParameterNeeded)
{
tableAttribute.AddParameter($"{nameof(TableAttribute.Schema)} = {CSharpHelper.Literal(schema)}");
}
ClassAnnotationsData.Add(new Dictionary <string, object>
{
{ "class-annotation", tableAttribute }
});
}
}
private void GenerateInversePropertyAttribute(INavigation navigation)
{
if (navigation.ForeignKey.PrincipalKey.IsPrimaryKey())
{
var inverseNavigation = navigation.Inverse;
if (inverseNavigation != null)
{
// TODO: Resolve TransformNavPropertyName() method
NavEntityPropertyInfo navEntityPropertyInfo = ResolvingNamesService.ResolvingName(navigation);
var foreignKeyAttribute = new AttributeWriter(nameof(ForeignKeyAttribute));
var inversePropertyAttribute = new AttributeWriter(nameof(InversePropertyAttribute));
var propertyName = EntityTypeTransformationService.TransformNavPropertyName(navEntityPropertyInfo.FieldName, navEntityPropertyInfo.ForeginEntityName, navEntityPropertyInfo.EntityName, inverseNavigation.Name, navigation.DeclaringType.Name, navEntityPropertyInfo.PropertyIsNullable);
inversePropertyAttribute.AddParameter(
!navigation.DeclaringEntityType.GetPropertiesAndNavigations().Any(
m => m.Name == inverseNavigation.DeclaringEntityType.Name ||
EntityTypeTransformationService.TransformNavPropertyName(navEntityPropertyInfo.FieldName, navEntityPropertyInfo.ForeginEntityName, navEntityPropertyInfo.EntityName, m.Name, navigation.TargetEntityType.Name, navEntityPropertyInfo.PropertyIsNullable)
== EntityTypeTransformationService.TransformNavPropertyName(navEntityPropertyInfo.FieldName, navEntityPropertyInfo.ForeginEntityName, navEntityPropertyInfo.EntityName, inverseNavigation.DeclaringEntityType.Name, navigation.TargetEntityType.Name, navEntityPropertyInfo.PropertyIsNullable))
? $"nameof({EntityTypeTransformationService.TransformTypeEntityName(inverseNavigation.DeclaringType.Name)}.{propertyName})"
: CSharpHelper.Literal(propertyName));
NavPropertyAnnotations.Add(new Dictionary <string, object>
{
{ "nav-property-annotation", inversePropertyAttribute }
});
}
}
}
private void GenerateForeignKeyAttribute(INavigation navigation)
{
if (navigation.IsOnDependent)
{
if (navigation.ForeignKey.PrincipalKey.IsPrimaryKey())
{
// TODO: Resolve TransformNavPropertyName() method
NavEntityPropertyInfo navEntityPropertyInfo = ResolvingNamesService.ResolvingName(navigation);
var foreignKeyAttribute = new AttributeWriter(nameof(ForeignKeyAttribute));
if (navigation.ForeignKey.Properties.Count > 1)
{
foreignKeyAttribute.AddParameter(
CSharpHelper.Literal(
string.Join(",", navigation.ForeignKey.Properties.Select(p => EntityTypeTransformationService.TransformNavPropertyName(navEntityPropertyInfo.FieldName, navEntityPropertyInfo.ForeginEntityName, navEntityPropertyInfo.EntityName, p.Name, p.ClrType.Name, navEntityPropertyInfo.PropertyIsNullable)))));
}
else
{
foreignKeyAttribute.AddParameter($"nameof({EntityTypeTransformationService.TransformNavPropertyName(navEntityPropertyInfo.FieldName, navEntityPropertyInfo.ForeginEntityName, navEntityPropertyInfo.EntityName, navigation.ForeignKey.Properties.First().Name, navigation.ForeignKey.Properties.First().ClrType.Name, navEntityPropertyInfo.PropertyIsNullable)})");
}
NavPropertyAnnotations.Add(new Dictionary <string, object>
{
{ "nav-property-annotation", foreignKeyAttribute }
});
}
}
}
private void GenerateRelationship(IForeignKey foreignKey, bool useDataAnnotations, IndentedStringBuilder sb)
{
var canUseDataAnnotations = true;
var annotations = AnnotationCodeGenerator
.FilterIgnoredAnnotations(foreignKey.GetAnnotations())
.ToDictionary(a => a.Name, a => a);
AnnotationCodeGenerator.RemoveAnnotationsHandledByConventions(foreignKey, annotations);
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.HasOne)}("
+ (foreignKey.DependentToPrincipal != null ? $"d => d.{EntityTypeTransformationService.TransformNavPropertyName(foreignKey.DependentToPrincipal?.Name, foreignKey.PrincipalToDependent?.DeclaringType.Name)}" : null)
+ ")",
$".{(foreignKey.IsUnique ? nameof(ReferenceNavigationBuilder.WithOne) : nameof(ReferenceNavigationBuilder.WithMany))}"
+ "("
+ (foreignKey.PrincipalToDependent != null ? $"p => p.{EntityTypeTransformationService.TransformNavPropertyName(foreignKey.PrincipalToDependent?.Name, foreignKey.DependentToPrincipal?.DeclaringType.Name)}" : null)
+ ")"
};
if (!foreignKey.PrincipalKey.IsPrimaryKey())
{
canUseDataAnnotations = false;
lines.Add(
$".{nameof(ReferenceReferenceBuilder.HasPrincipalKey)}"
+ (foreignKey.IsUnique ? $"<{EntityTypeTransformationService.TransformPropertyName(((ITypeBase)foreignKey.PrincipalEntityType).DisplayName(), "")}>" : "")
+ $"(p => {GenerateLambdaToKey(foreignKey.PrincipalKey.Properties, "p", EntityTypeTransformationService.TransformNavPropertyName)})");
}
lines.Add(
$".{nameof(ReferenceReferenceBuilder.HasForeignKey)}"
+ (foreignKey.IsUnique ? $"<{GetEntityTypeName(foreignKey.PrincipalEntityType, EntityTypeTransformationService.TransformTypeEntityName(((ITypeBase)foreignKey.DeclaringEntityType).DisplayName()))}>" : "")
+ $"(d => {GenerateLambdaToKey(foreignKey.Properties, "d", EntityTypeTransformationService.TransformPropertyName)})");
var defaultOnDeleteAction = foreignKey.IsRequired
? DeleteBehavior.Cascade
: DeleteBehavior.ClientSetNull;
if (foreignKey.DeleteBehavior != defaultOnDeleteAction)
{
canUseDataAnnotations = false;
lines.Add(
$".{nameof(ReferenceReferenceBuilder.OnDelete)}({CSharpHelper.Literal(foreignKey.DeleteBehavior)})");
}
if (!string.IsNullOrEmpty((string)foreignKey[RelationalAnnotationNames.Name]))
{
canUseDataAnnotations = false;
}
lines.AddRange(
AnnotationCodeGenerator.GenerateFluentApiCalls(foreignKey, annotations).Select(m => CSharpHelper.Fragment(m))
.Concat(GenerateAnnotations(annotations.Values)));
if (!useDataAnnotations ||
!canUseDataAnnotations)
{
AppendMultiLineFluentApi(foreignKey.DeclaringEntityType, lines, sb);
}
}
private void GenerateForeignKeyAttribute(INavigation navigation)
{
if (navigation.IsDependentToPrincipal())
{
if (navigation.ForeignKey.PrincipalKey.IsPrimaryKey())
{
var foreignKeyAttribute = new AttributeWriter(nameof(ForeignKeyAttribute));
if (navigation.ForeignKey.Properties.Count > 1)
{
foreignKeyAttribute.AddParameter(
CSharpHelper.Literal(
string.Join(",", navigation.ForeignKey.Properties.Select(p => EntityTypeTransformationService.TransformNavPropertyName(p.Name, p.ClrType.Name)))));
}
else
{
foreignKeyAttribute.AddParameter($"nameof({EntityTypeTransformationService.TransformNavPropertyName(navigation.ForeignKey.Properties.First().Name, navigation.ForeignKey.Properties.First().ClrType.Name)})");
}
NavPropertyAnnotations.Add(new Dictionary <string, object>
{
{ "nav-property-annotation", foreignKeyAttribute.ToString() },
});
}
}
}
private void GenerateIndex(IIndex index, IndentedStringBuilder sb)
{
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.HasIndex)}(e => {GenerateLambdaToKey(index.Properties, "e")})"
};
var annotations = index.GetAnnotations().ToList();
if (!string.IsNullOrEmpty((string)index[RelationalAnnotationNames.Name]))
{
lines.Add(
$".{nameof(RelationalIndexBuilderExtensions.HasName)}" +
$"({CSharpHelper.Literal(index.Relational().Name)})");
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Name);
}
if (index.IsUnique)
{
lines.Add($".{nameof(IndexBuilder.IsUnique)}()");
}
if (index.Relational().Filter != null)
{
lines.Add(
$".{nameof(RelationalIndexBuilderExtensions.HasFilter)}" +
$"({CSharpHelper.Literal(index.Relational().Filter)})");
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Filter);
}
var annotationsToRemove = new List <IAnnotation>();
foreach (var annotation in annotations)
{
if (CodeGenerator.IsHandledByConvention(index, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
#pragma warning disable CS0618 // Type or member is obsolete
var line = CodeGenerator.GenerateFluentApi(index, annotation, Language);
#pragma warning restore CS0618 // Type or member is obsolete
if (line != null)
{
lines.Add(line);
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
AppendMultiLineFluentApi(index.DeclaringEntityType, lines, sb);
}
protected virtual void GenerateEntityType(
[NotNull] IEntityType entityType, [NotNull] IndentedStringBuilder stringBuilder, GenerateEntityTypeOptions options)
{
Check.NotNull(entityType, nameof(entityType));
Check.NotNull(stringBuilder, nameof(stringBuilder));
stringBuilder
.Append("builder.Entity(")
.Append(_code.Literal(entityType.Name))
.AppendLine(", b =>");
using (stringBuilder.Indent())
{
stringBuilder.Append("{");
using (stringBuilder.Indent())
{
if ((options & GenerateEntityTypeOptions.Primary) != 0)
{
GenerateProperties(entityType.GetProperties(), stringBuilder);
GenerateKey(entityType.GetPrimaryKey(), stringBuilder);
GenerateIndexes(entityType.GetIndexes(), stringBuilder);
}
if ((options & GenerateEntityTypeOptions.Secondary) != 0)
{
GenerateForeignKeys(entityType.GetForeignKeys(), stringBuilder);
}
if ((options & GenerateEntityTypeOptions.Primary) != 0)
{
GenerateEntityTypeAnnotations(entityType, stringBuilder);
}
}
stringBuilder
.AppendLine()
.AppendLine("});");
}
}
private void GenerateIndex(IIndex index, IndentedStringBuilder sb)
{
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.HasIndex)}(e => {GenerateLambdaToKey(index.Properties, "e")})"
};
var annotations = index.GetAnnotations().ToList();
if (!string.IsNullOrEmpty((string)index[RelationalAnnotationNames.Name]))
{
lines.Add(
$".{nameof(RelationalIndexBuilderExtensions.HasName)}" +
$"({CSharpHelper.Literal(index.GetName())})");
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Name);
}
if (index.IsUnique)
{
lines.Add($".{nameof(IndexBuilder.IsUnique)}()");
}
if (index.GetFilter() != null)
{
lines.Add(
$".{nameof(RelationalIndexBuilderExtensions.HasFilter)}" +
$"({CSharpHelper.Literal(index.GetFilter())})");
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Filter);
}
var annotationsToRemove = new List <IAnnotation>();
foreach (var annotation in annotations)
{
if (annotation.Value == null ||
AnnotationCodeGenerator.IsHandledByConvention(index, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
var methodCall = AnnotationCodeGenerator.GenerateFluentApi(index, annotation);
if (methodCall != null)
{
lines.Add(CSharpHelper.Fragment(methodCall));
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
AppendMultiLineFluentApi(index.DeclaringEntityType, lines, sb);
}
private void GenerateForeignKeyAttribute(INavigation navigation)
{
if (navigation.IsDependentToPrincipal())
{
if (navigation.ForeignKey.PrincipalKey.IsPrimaryKey())
{
var foreignKeyAttribute = new AttributeWriter(nameof(ForeignKeyAttribute));
foreignKeyAttribute.AddParameter(
CSharpHelper.Literal(
string.Join(",", navigation.ForeignKey.Properties.Select(p => p.Name))));
NavPropertyAnnotations.Add(new Dictionary <string, object>
{
{ "nav-property-annotation", foreignKeyAttribute.ToString() },
});
}
}
}
private void GenerateInversePropertyAttribute(INavigation navigation)
{
if (navigation.ForeignKey.PrincipalKey.IsPrimaryKey())
{
var inverseNavigation = navigation.FindInverse();
if (inverseNavigation != null)
{
var inversePropertyAttribute = new AttributeWriter(nameof(InversePropertyAttribute));
inversePropertyAttribute.AddParameter(CSharpHelper.Literal(inverseNavigation.Name));
NavPropertyAnnotations.Add(new Dictionary <string, object>
{
{ "nav-property-annotation", inversePropertyAttribute.ToString() },
});
}
}
}
private void GenerateMaxLengthAttribute(IProperty property)
{
var maxLength = property.GetMaxLength();
if (maxLength.HasValue)
{
var lengthAttribute = new AttributeWriter(
property.ClrType == typeof(string)
? nameof(StringLengthAttribute)
: nameof(MaxLengthAttribute));
lengthAttribute.AddParameter(CSharpHelper.Literal(maxLength.Value));
PropertyAnnotationsData.Add(new Dictionary <string, object>
{
{ "property-annotation", lengthAttribute.ToString() },
});
}
}
private void GenerateTableAttribute(IEntityType entityType)
{
var tableName = entityType.Relational().TableName;
var schema = entityType.Relational().Schema;
var defaultSchema = entityType.Model.Relational().DefaultSchema;
var schemaParameterNeeded = schema != null && schema != defaultSchema;
var tableAttributeNeeded = schemaParameterNeeded || tableName != null && tableName != entityType.Scaffolding().DbSetName;
if (tableAttributeNeeded)
{
var tableAttribute = new AttributeWriter(nameof(TableAttribute));
tableAttribute.AddParameter(CSharpHelper.Literal(tableName));
if (schemaParameterNeeded)
{
tableAttribute.AddParameter($"{nameof(TableAttribute.Schema)} = {CSharpHelper.Literal(schema)}");
}
TemplateData.Add("class-annotation", tableAttribute.ToString());
}
}
private void GenerateKey(IKey key, IEntityType entityType, bool useDataAnnotations, IndentedStringBuilder sb)
{
if (key == null)
{
if (!useDataAnnotations)
{
var line = new List <string> {
$".{nameof(EntityTypeBuilder.HasNoKey)}()"
};
AppendMultiLineFluentApi(entityType, line, sb);
}
return;
}
var annotations = AnnotationCodeGenerator
.FilterIgnoredAnnotations(key.GetAnnotations())
.ToDictionary(a => a.Name, a => a);
AnnotationCodeGenerator.RemoveAnnotationsHandledByConventions(key, annotations);
var explicitName = key.GetName() != key.GetDefaultName();
annotations.Remove(RelationalAnnotationNames.Name);
if (key.Properties.Count == 1 &&
annotations.Count == 0)
{
if (key is Key concreteKey &&
key.Properties.SequenceEqual(
KeyDiscoveryConvention.DiscoverKeyProperties(
concreteKey.DeclaringEntityType,
concreteKey.DeclaringEntityType.GetProperties())))
{
return;
}
if (!explicitName &&
useDataAnnotations)
{
return;
}
}
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.HasKey)}(e => {GenerateLambdaToKey(key.Properties, "e", EntityTypeTransformationService.TransformPropertyName)})"
};
if (explicitName)
{
lines.Add(
$".{nameof(RelationalKeyBuilderExtensions.HasName)}" +
$"({CSharpHelper.Literal(key.GetName())})");
}
lines.AddRange(
AnnotationCodeGenerator.GenerateFluentApiCalls(key, annotations).Select(m => CSharpHelper.Fragment(m))
.Concat(GenerateAnnotations(annotations.Values)));
AppendMultiLineFluentApi(key.DeclaringEntityType, lines, sb);
}
private void GenerateRelationship(IForeignKey foreignKey, bool useDataAnnotations, IndentedStringBuilder sb)
{
var canUseDataAnnotations = true;
var annotations = foreignKey.GetAnnotations().ToList();
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.HasOne)}(" + (foreignKey.DependentToPrincipal != null ? $"d => d.{foreignKey.DependentToPrincipal.Name}" : null) + ")",
$".{(foreignKey.IsUnique ? nameof(ReferenceNavigationBuilder.WithOne) : nameof(ReferenceNavigationBuilder.WithMany))}"
+ $"(" + (foreignKey.PrincipalToDependent != null ? $"p => p.{foreignKey.PrincipalToDependent.Name}" : null) + ")"
};
if (!foreignKey.PrincipalKey.IsPrimaryKey())
{
canUseDataAnnotations = false;
lines.Add(
$".{nameof(ReferenceReferenceBuilder.HasPrincipalKey)}"
+ (foreignKey.IsUnique ? $"<{((ITypeBase)foreignKey.PrincipalEntityType).DisplayName()}>" : "")
+ $"(p => {GenerateLambdaToKey(foreignKey.PrincipalKey.Properties, "p")})");
}
lines.Add(
$".{nameof(ReferenceReferenceBuilder.HasForeignKey)}"
+ (foreignKey.IsUnique ? $"<{((ITypeBase)foreignKey.DeclaringEntityType).DisplayName()}>" : "")
+ $"(d => {GenerateLambdaToKey(foreignKey.Properties, "d")})");
var defaultOnDeleteAction = foreignKey.IsRequired
? DeleteBehavior.Cascade
: DeleteBehavior.ClientSetNull;
if (foreignKey.DeleteBehavior != defaultOnDeleteAction)
{
canUseDataAnnotations = false;
lines.Add(
$".{nameof(ReferenceReferenceBuilder.OnDelete)}" +
$"({CSharpHelper.Literal(foreignKey.DeleteBehavior)})");
}
if (!string.IsNullOrEmpty((string)foreignKey[RelationalAnnotationNames.Name]))
{
canUseDataAnnotations = false;
lines.Add(
$".HasConstraintName" +
$"({CSharpHelper.Literal(foreignKey.GetConstraintName())})");
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Name);
}
var annotationsToRemove = new List <IAnnotation>();
foreach (var annotation in annotations)
{
if (annotation.Value == null ||
AnnotationCodeGenerator.IsHandledByConvention(foreignKey, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
var methodCall = AnnotationCodeGenerator.GenerateFluentApi(foreignKey, annotation);
if (methodCall != null)
{
canUseDataAnnotations = false;
lines.Add(CSharpHelper.Fragment(methodCall));
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
if (!useDataAnnotations ||
!canUseDataAnnotations)
{
AppendMultiLineFluentApi(foreignKey.DeclaringEntityType, lines, sb);
}
}
private void GenerateProperty(IProperty property, bool useDataAnnotations, IndentedStringBuilder sb)
{
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.Property)}(e => e.{property.Name})"
};
var annotations = property.GetAnnotations().ToList();
RemoveAnnotation(ref annotations, RelationalAnnotationNames.ColumnName);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.ColumnType);
RemoveAnnotation(ref annotations, CoreAnnotationNames.MaxLength);
RemoveAnnotation(ref annotations, CoreAnnotationNames.TypeMapping);
RemoveAnnotation(ref annotations, CoreAnnotationNames.Unicode);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.DefaultValue);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.DefaultValueSql);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Comment);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.ComputedColumnSql);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.IsFixedLength);
RemoveAnnotation(ref annotations, ScaffoldingAnnotationNames.ColumnOrdinal);
if (!useDataAnnotations)
{
if (!property.IsNullable &&
property.ClrType.IsNullableType() &&
!property.IsPrimaryKey())
{
lines.Add($".{nameof(PropertyBuilder.IsRequired)}()");
}
var columnName = property.GetColumnName();
if (columnName != null &&
columnName != property.Name)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasColumnName)}" +
$"({CSharpHelper.Literal(columnName)})");
}
var columnType = property.GetConfiguredColumnType();
if (columnType != null)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasColumnType)}" +
$"({CSharpHelper.Literal(columnType)})");
}
var maxLength = property.GetMaxLength();
if (maxLength.HasValue)
{
lines.Add(
$".{nameof(PropertyBuilder.HasMaxLength)}" +
$"({CSharpHelper.Literal(maxLength.Value)})");
}
}
if (property.IsUnicode() != null)
{
lines.Add(
$".{nameof(PropertyBuilder.IsUnicode)}" +
$"({(property.IsUnicode() == false ? "false" : "")})");
}
if (property.IsFixedLength())
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.IsFixedLength)}()");
}
if (property.GetDefaultValue() != null)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasDefaultValue)}" +
$"({CSharpHelper.UnknownLiteral(property.GetDefaultValue())})");
}
if (property.GetDefaultValueSql() != null)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasDefaultValueSql)}" +
$"({CSharpHelper.Literal(property.GetDefaultValueSql())})");
}
if (property.GetComment() != null)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasComment)}" +
$"({CSharpHelper.Literal(property.GetComment())})");
}
if (property.GetComputedColumnSql() != null)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasComputedColumnSql)}" +
$"({CSharpHelper.Literal(property.GetComputedColumnSql())})");
}
var valueGenerated = property.ValueGenerated;
var isRowVersion = false;
if (((IConventionProperty)property).GetValueGeneratedConfigurationSource().HasValue &&
RelationalValueGenerationConvention.GetValueGenerated(property) != valueGenerated)
{
string methodName;
switch (valueGenerated)
{
case ValueGenerated.OnAdd:
methodName = nameof(PropertyBuilder.ValueGeneratedOnAdd);
break;
case ValueGenerated.OnAddOrUpdate:
isRowVersion = property.IsConcurrencyToken;
methodName = isRowVersion
? nameof(PropertyBuilder.IsRowVersion)
: nameof(PropertyBuilder.ValueGeneratedOnAddOrUpdate);
break;
case ValueGenerated.Never:
methodName = nameof(PropertyBuilder.ValueGeneratedNever);
break;
default:
methodName = "";
break;
}
lines.Add($".{methodName}()");
}
if (property.IsConcurrencyToken &&
!isRowVersion)
{
lines.Add($".{nameof(PropertyBuilder.IsConcurrencyToken)}()");
}
var annotationsToRemove = new List <IAnnotation>();
foreach (var annotation in annotations)
{
if (annotation.Value == null ||
AnnotationCodeGenerator.IsHandledByConvention(property, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
var methodCall = AnnotationCodeGenerator.GenerateFluentApi(property, annotation);
if (methodCall != null)
{
lines.Add(CSharpHelper.Fragment(methodCall));
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
switch (lines.Count)
{
case 1:
return;
case 2:
lines = new List <string>
{
lines[0] + lines[1]
};
break;
}
AppendMultiLineFluentApi(property.DeclaringEntityType, lines, sb);
}
protected virtual void GenerateEntityType(
[NotNull] IEntityType entityType, [NotNull] IndentedStringBuilder stringBuilder, GenerateEntityTypeOptions options)
{
Check.NotNull(entityType, nameof(entityType));
Check.NotNull(stringBuilder, nameof(stringBuilder));
if ((options & GenerateEntityTypeOptions.BaseType) != 0)
{
stringBuilder
.Append("builder.Entity(")
.Append(_code.Literal(entityType.Name))
.AppendLine(")");
using (stringBuilder.Indent())
{
stringBuilder.Append(".BaseType(")
.Append(_code.Literal(entityType.BaseType.Name))
.AppendLine(");");
}
return;
}
stringBuilder
.Append("builder.Entity(")
.Append(_code.Literal(entityType.Name))
.AppendLine(", b =>");
using (stringBuilder.Indent())
{
stringBuilder.Append("{");
using (stringBuilder.Indent())
{
if ((options & GenerateEntityTypeOptions.Declared) != 0)
{
GenerateProperties(entityType.GetDeclaredProperties(), stringBuilder);
GenerateKey(entityType.FindDeclaredPrimaryKey(), stringBuilder);
GenerateIndexes(entityType.GetDeclaredIndexes(), stringBuilder);
}
if ((options & GenerateEntityTypeOptions.Relationships) != 0)
{
GenerateForeignKeys(entityType.GetDeclaredForeignKeys(), stringBuilder);
}
if ((options & GenerateEntityTypeOptions.Declared) != 0)
{
GenerateEntityTypeAnnotations(entityType, stringBuilder);
}
}
stringBuilder
.AppendLine()
.AppendLine("});");
}
}
private void GenerateSequence(ISequence sequence, IndentedStringBuilder sb)
{
var methodName = nameof(RelationalModelBuilderExtensions.HasSequence);
if (sequence.Type != Sequence.DefaultClrType)
{
methodName += $"<{CSharpHelper.Reference(sequence.Type)}>";
}
var parameters = CSharpHelper.Literal(sequence.Name);
if (!string.IsNullOrEmpty(sequence.Schema) &&
sequence.Model.GetDefaultSchema() != sequence.Schema)
{
parameters += $", {CSharpHelper.Literal(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(";");
}
protected virtual void Generate([NotNull] AddColumnOperation operation, [NotNull] IndentedStringBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder.AppendLine(".AddColumn(");
using (builder.Indent())
{
builder
.Append("name: ")
.Append(_code.Literal(operation.Name));
if (operation.Schema != null)
{
builder
.AppendLine(",")
.Append("schema: ")
.Append(_code.Literal(operation.Schema));
}
builder
.AppendLine(",")
.Append("table: ")
.Append(_code.Literal(operation.Table))
.AppendLine(",")
.Append("type: ")
.Append(_code.Literal(operation.Type))
.AppendLine(",")
.Append("nullable: ")
.Append(_code.Literal(operation.IsNullable));
if (operation.DefaultValueSql != null)
{
builder
.AppendLine(",")
.Append("defaultValueSql: ")
.Append(_code.Literal(operation.DefaultValueSql));
}
else if (operation.ComputedColumnSql != null)
{
builder
.AppendLine(",")
.Append("computedColumnSql: ")
.Append(_code.UnknownLiteral(operation.ComputedColumnSql));
}
else if (operation.DefaultValue != null)
{
builder
.AppendLine(",")
.Append("defaultValue: ")
.Append(_code.UnknownLiteral(operation.DefaultValue));
}
builder.Append(")");
Annotations(operation.Annotations, builder);
}
}
public override string GenerateMetadata(
string migrationNamespace,
Type contextType,
string migrationName,
string migrationId,
IModel targetModel)
{
Check.NotEmpty(migrationNamespace, nameof(migrationNamespace));
Check.NotNull(contextType, nameof(contextType));
Check.NotEmpty(migrationName, nameof(migrationName));
Check.NotEmpty(migrationId, nameof(migrationId));
Check.NotNull(targetModel, nameof(targetModel));
var builder = new IndentedStringBuilder();
var namespaces = new List <string>
{
"System",
"Microsoft.Data.Entity",
"Microsoft.Data.Entity.Infrastructure",
"Microsoft.Data.Entity.Metadata",
"Microsoft.Data.Entity.Migrations",
contextType.Namespace
};
namespaces.AddRange(GetNamespaces(targetModel));
foreach (var n in namespaces.Distinct())
{
builder
.Append("using ")
.Append(n)
.AppendLine(";");
}
builder
.AppendLine()
.Append("namespace ").AppendLine(_code.Namespace(migrationNamespace))
.AppendLine("{");
using (builder.Indent())
{
builder
.Append("[DbContext(typeof(").Append(_code.Reference(contextType)).AppendLine("))]")
.Append("partial class ").AppendLine(_code.Identifier(migrationName))
.AppendLine("{");
using (builder.Indent())
{
builder
.AppendLine("public override string Id")
.AppendLine("{");
using (builder.Indent())
{
builder.Append("get { return ").Append(_code.Literal(migrationId)).AppendLine("; }");
}
builder
.AppendLine("}")
.AppendLine()
.AppendLine("protected override void BuildTargetModel(ModelBuilder modelBuilder)")
.AppendLine("{");
using (builder.Indent())
{
// TODO: Optimize. This is repeated below
_modelGenerator.Generate("modelBuilder", targetModel, builder);
}
builder.AppendLine("}");
}
builder.AppendLine("}");
}
builder.AppendLine("}");
return(builder.ToString());
}
private void GenerateRelationship(IForeignKey foreignKey, string dependentPropName, string principalPropName,
bool useDataAnnotations, IndentedStringBuilder sb)
{
var canUseDataAnnotations = true;
var annotations = foreignKey.GetAnnotations().ToList();
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.HasOne)}(d => d.{dependentPropName})",
$".{(foreignKey.IsUnique ? nameof(ReferenceNavigationBuilder.WithOne) : nameof(ReferenceNavigationBuilder.WithMany))}"
+ $"(p => p.{principalPropName})"
};
if (!foreignKey.PrincipalKey.IsPrimaryKey())
{
canUseDataAnnotations = false;
var principlePropDisplayName = EntityTypeTransformationService
.TransformPropertyName(foreignKey.PrincipalEntityType.DisplayName());
lines.Add(
$".{nameof(ReferenceReferenceBuilder.HasPrincipalKey)}"
+ $"{(foreignKey.IsUnique ? $"<{principlePropDisplayName}>" : "")}"
+ $"(p => {GenerateLambdaToKey(foreignKey.PrincipalKey.Properties, "p")})");
}
var dependentPropDisplayName = EntityTypeTransformationService
.TransformPropertyName(foreignKey.DeclaringEntityType.DisplayName());
lines.Add(
$".{nameof(ReferenceReferenceBuilder.HasForeignKey)}"
+ $"{(foreignKey.IsUnique ? $"<{dependentPropDisplayName}>" : "")}"
+ $"(d => {GenerateLambdaToKey(foreignKey.Properties, "d")})");
var defaultOnDeleteAction = foreignKey.IsRequired
? DeleteBehavior.Cascade
: DeleteBehavior.ClientSetNull;
if (foreignKey.DeleteBehavior != defaultOnDeleteAction)
{
canUseDataAnnotations = false;
lines.Add(
$".{nameof(ReferenceReferenceBuilder.OnDelete)}" +
$"({CSharpHelper.Literal(foreignKey.DeleteBehavior)})");
}
if (!string.IsNullOrEmpty((string)foreignKey[RelationalAnnotationNames.Name]))
{
canUseDataAnnotations = false;
lines.Add(
$".{nameof(RelationalReferenceReferenceBuilderExtensions.HasConstraintName)}" +
$"({CSharpHelper.Literal(foreignKey.Relational().Name)})");
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Name);
}
var annotationsToRemove = new List <IAnnotation>();
foreach (var annotation in annotations)
{
if (CodeGenerator.IsHandledByConvention(foreignKey, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
#pragma warning disable CS0618 // Type or member is obsolete
var line = CodeGenerator.GenerateFluentApi(foreignKey, annotation, Language);
#pragma warning restore CS0618 // Type or member is obsolete
if (line != null)
{
canUseDataAnnotations = false;
lines.Add(line);
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
if (!useDataAnnotations ||
!canUseDataAnnotations)
{
AppendMultiLineFluentApi(foreignKey.DeclaringEntityType, lines, sb);
}
}
private void GenerateKey(IKey key, bool useDataAnnotations, IndentedStringBuilder sb)
{
if (key == null)
{
return;
}
var annotations = key.GetAnnotations().ToList();
var explicitName = key.Relational().Name != ConstraintNamer.GetDefaultName(key);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Name);
if (key.Properties.Count == 1)
{
if (key is Key concreteKey &&
key.Properties.SequenceEqual(new KeyDiscoveryConvention(null).DiscoverKeyProperties(concreteKey.DeclaringEntityType, concreteKey.DeclaringEntityType.GetProperties().ToList())))
{
return;
}
if (!explicitName &&
useDataAnnotations)
{
return;
}
}
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.HasKey)}(e => {GenerateLambdaToKey(key.Properties, "e")})"
};
if (explicitName)
{
lines.Add($".{nameof(RelationalKeyBuilderExtensions.HasName)}" +
$"({CSharpHelper.Literal(key.Relational().Name)})");
}
var annotationsToRemove = new List <IAnnotation>();
foreach (var annotation in annotations)
{
if (CodeGenerator.IsHandledByConvention(key, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
#pragma warning disable CS0618 // Type or member is obsolete
var line = CodeGenerator.GenerateFluentApi(key, annotation, Language);
#pragma warning restore CS0618 // Type or member is obsolete
if (line != null)
{
lines.Add(line);
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
AppendMultiLineFluentApi(key.DeclaringEntityType, lines, sb);
}
private void GenerateProperty(IProperty property, bool useDataAnnotations, IndentedStringBuilder sb)
{
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.Property)}(e => e.{EntityTypeTransformationService.TransformPropertyName(property.Name, property.DeclaringType.Name)})"
};
var annotations = AnnotationCodeGenerator
.FilterIgnoredAnnotations(property.GetAnnotations())
.ToDictionary(a => a.Name, a => a);
AnnotationCodeGenerator.RemoveAnnotationsHandledByConventions(property, annotations);
annotations.Remove(ScaffoldingAnnotationNames.ColumnOrdinal);
if (useDataAnnotations)
{
// Strip out any annotations handled as attributes - these are already handled when generating
// the entity's properties
// Only relational ones need to be removed here. Core ones are already removed by FilterIgnoredAnnotations
annotations.Remove(RelationalAnnotationNames.ColumnName);
annotations.Remove(RelationalAnnotationNames.ColumnType);
_ = AnnotationCodeGenerator.GenerateDataAnnotationAttributes(property, annotations);
}
else
{
if (!property.IsNullable &&
property.ClrType.IsNullableType() &&
!property.IsPrimaryKey())
{
lines.Add($".{nameof(PropertyBuilder.IsRequired)}()");
}
var columnType = property.GetConfiguredColumnType();
if (columnType != null)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasColumnType)}({CSharpHelper.Literal(columnType)})");
annotations.Remove(RelationalAnnotationNames.ColumnType);
}
var maxLength = property.GetMaxLength();
if (maxLength.HasValue)
{
lines.Add(
$".{nameof(PropertyBuilder.HasMaxLength)}({CSharpHelper.Literal(maxLength.Value)})");
}
}
var precision = property.GetPrecision();
var scale = property.GetScale();
if (precision != null && scale != null && scale != 0)
{
lines.Add(
$".{nameof(PropertyBuilder.HasPrecision)}({CSharpHelper.Literal(precision.Value)}, {CSharpHelper.Literal(scale.Value)})");
}
else if (precision != null)
{
lines.Add(
$".{nameof(PropertyBuilder.HasPrecision)}({CSharpHelper.Literal(precision.Value)})");
}
if (property.IsUnicode() != null)
{
lines.Add(
$".{nameof(PropertyBuilder.IsUnicode)}({(property.IsUnicode() == false ? "false" : "")})");
}
var defaultValue = property.GetDefaultValue();
if (defaultValue == DBNull.Value)
{
lines.Add($".{nameof(RelationalPropertyBuilderExtensions.HasDefaultValue)}()");
annotations.Remove(RelationalAnnotationNames.DefaultValue);
}
else if (defaultValue != null)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasDefaultValue)}({CSharpHelper.UnknownLiteral(defaultValue)})");
annotations.Remove(RelationalAnnotationNames.DefaultValue);
}
var valueGenerated = property.ValueGenerated;
var isRowVersion = false;
if (((IConventionProperty)property).GetValueGeneratedConfigurationSource() is ConfigurationSource
valueGeneratedConfigurationSource &&
valueGeneratedConfigurationSource != ConfigurationSource.Convention &&
ValueGenerationConvention.GetValueGenerated(property) != valueGenerated)
{
var methodName = valueGenerated switch
{
ValueGenerated.OnAdd => nameof(PropertyBuilder.ValueGeneratedOnAdd),
ValueGenerated.OnAddOrUpdate => property.IsConcurrencyToken
? nameof(PropertyBuilder.IsRowVersion)
: nameof(PropertyBuilder.ValueGeneratedOnAddOrUpdate),
ValueGenerated.OnUpdate => nameof(PropertyBuilder.ValueGeneratedOnUpdate),
ValueGenerated.Never => nameof(PropertyBuilder.ValueGeneratedNever),
_ => throw new InvalidOperationException(DesignStrings.UnhandledEnumValue($"{nameof(ValueGenerated)}.{valueGenerated}"))
};
lines.Add($".{methodName}()");
}
if (property.IsConcurrencyToken &&
!isRowVersion)
{
lines.Add($".{nameof(PropertyBuilder.IsConcurrencyToken)}()");
}
lines.AddRange(
AnnotationCodeGenerator.GenerateFluentApiCalls(property, annotations).Select(m => CSharpHelper.Fragment(m))
.Concat(GenerateAnnotations(annotations.Values)));
switch (lines.Count)
{
case 1:
return;
case 2:
lines = new List <string> {
lines[0] + lines[1]
};
break;
}
AppendMultiLineFluentApi(property.DeclaringEntityType, lines, sb);
}
private void GenerateIndexAttributes(IEntityType entityType)
{
// Do not generate IndexAttributes for indexes which
// would be generated anyway by convention.
foreach (var index in entityType.GetIndexes().Where(
i => ConfigurationSource.Convention != ((IConventionIndex)i).GetConfigurationSource()))
{
// If there are annotations that cannot be represented using an IndexAttribute then use fluent API instead.
var annotations = AnnotationCodeGenerator
.FilterIgnoredAnnotations(index.GetAnnotations())
.ToDictionary(a => a.Name, a => a);
AnnotationCodeGenerator.RemoveAnnotationsHandledByConventions(index, annotations);
if (annotations.Count == 0)
{
var indexAttribute = new AttributeWriter(nameof(IndexAttribute));
foreach (var property in index.Properties)
{
indexAttribute.AddParameter($"nameof({property.Name})");
}
if (index.Name != null)
{
indexAttribute.AddParameter($"{nameof(IndexAttribute.Name)} = {CSharpHelper.Literal(index.Name)}");
}
if (index.IsUnique)
{
indexAttribute.AddParameter($"{nameof(IndexAttribute.IsUnique)} = {CSharpHelper.Literal(index.IsUnique)}");
}
ClassAnnotationsData.Add(new Dictionary <string, object>
{
{ "class-annotation", indexAttribute }
});
}
}
}
private void GenerateEntityType(IEntityType entityType, bool useDataAnnotations, IndentedStringBuilder sb)
{
GenerateKey(entityType.FindPrimaryKey(), entityType, useDataAnnotations, sb);
var annotations = entityType.GetAnnotations().ToList();
RemoveAnnotation(ref annotations, CoreAnnotationNames.ConstructorBinding);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.TableName);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Comment);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Schema);
RemoveAnnotation(ref annotations, ScaffoldingAnnotationNames.DbSetName);
RemoveAnnotation(ref annotations, RelationalAnnotationNames2.ViewDefinition);
var isView = entityType.FindAnnotation(RelationalAnnotationNames2.ViewDefinition) != null;
if (!useDataAnnotations || isView)
{
GenerateTableName(entityType, sb);
}
var annotationsToRemove = new List <IAnnotation>();
var lines = new List <string>();
foreach (var annotation in annotations)
{
if (annotation.Value == null ||
AnnotationCodeGenerator.IsHandledByConvention(entityType, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
var methodCall = AnnotationCodeGenerator.GenerateFluentApi(entityType, annotation);
if (methodCall != null)
{
lines.Add(CSharpHelper.Fragment(methodCall));
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
if (entityType.GetComment() != null)
{
lines.Add(
$".{nameof(RelationalEntityTypeBuilderExtensions.HasComment)}" +
$"({CSharpHelper.Literal(entityType.GetComment())})");
}
AppendMultiLineFluentApi(entityType, lines, sb);
foreach (var index in entityType.GetIndexes())
{
GenerateIndex(index, sb);
}
foreach (var property in entityType.GetProperties())
{
GenerateProperty(property, useDataAnnotations, sb);
}
foreach (var foreignKey in entityType.GetScaffoldForeignKeys(_options.Value))
{
GenerateRelationship(foreignKey, useDataAnnotations, sb);
}
}
private string GenerateAnnotation(IAnnotation annotation)
=> $".HasAnnotation({CSharpHelper.Literal(annotation.Name)}, " +
$"{CSharpHelper.UnknownLiteral(annotation.Value)})";
private void GenerateKey(IKey key, IEntityType entityType, bool useDataAnnotations, IndentedStringBuilder sb)
{
if (key == null)
{
var line = new List <string>
{
$".{nameof(EntityTypeBuilder.HasNoKey)}()"
};
AppendMultiLineFluentApi(entityType, line, sb);
return;
}
var annotations = key.GetAnnotations().ToList();
var explicitName = key.GetName() != key.GetDefaultName();
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Name);
if (key.Properties.Count == 1 &&
annotations.Count == 0)
{
if (key is Key concreteKey &&
key.Properties.SequenceEqual(
KeyDiscoveryConvention.DiscoverKeyProperties(
concreteKey.DeclaringEntityType,
concreteKey.DeclaringEntityType.GetProperties())))
{
return;
}
if (!explicitName &&
useDataAnnotations)
{
return;
}
}
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.HasKey)}(e => {GenerateLambdaToKey(key.Properties, "e")})"
};
if (explicitName)
{
lines.Add(
$".{nameof(RelationalKeyBuilderExtensions.HasName)}" +
$"({CSharpHelper.Literal(key.GetName())})");
}
var annotationsToRemove = new List <IAnnotation>();
foreach (var annotation in annotations)
{
if (annotation.Value == null ||
AnnotationCodeGenerator.IsHandledByConvention(key, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
var methodCall = AnnotationCodeGenerator.GenerateFluentApi(key, annotation);
if (methodCall != null)
{
lines.Add(CSharpHelper.Fragment(methodCall));
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
AppendMultiLineFluentApi(key.DeclaringEntityType, lines, sb);
}