public static ModelBuilder ConfigureIEntityTypes <TId, TUserId>(this ModelBuilder modelBuilder)
where TId : struct
where TUserId : struct
{
foreach (IMutableEntityType entityType in modelBuilder.Model.GetEntityTypes().Where(t => typeof(IEntity <TId, TUserId>).IsAssignableFrom(t.ClrType)))
{
// Id
IMutableProperty id = entityType.FindProperty(nameof(IEntity <TId, TUserId> .Id));
entityType.SetPrimaryKey(id);
// CreatedOn
IMutableProperty createdOn = entityType.FindProperty(nameof(IEntity <TId, TUserId> .CreatedOn));
createdOn.SetValueGeneratorFactory((p, e) => new UtcNowDateTimeValueGenerator());
createdOn.ValueGenerated = ValueGenerated.OnAdd;
createdOn.SetValueConverter(new UtcDateTimeValueConverter());
// ModifiedOn
IMutableProperty modifiedOn = entityType.FindProperty(nameof(IEntity <TId, TUserId> .ModifiedOn));
modifiedOn.SetValueGeneratorFactory((p, e) => new UtcNowDateTimeValueGenerator());
// Workaround. See: https://github.com/dotnet/efcore/issues/6999
//modifiedOn.ValueGenerated = ValueGenerated.OnAddOrUpdate;
modifiedOn.ValueGenerated = ValueGenerated.OnAdd;
modifiedOn.SetValueConverter(new UtcDateTimeValueConverter());
// RowVersion
IMutableProperty rowVersion = entityType.FindProperty(nameof(IEntity <TId, TUserId> .RowVersion));
rowVersion.ValueGenerated = ValueGenerated.OnAddOrUpdate;
rowVersion.IsConcurrencyToken = true;
}
return(modelBuilder);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual void Apply(IMutableProperty property)
{
foreach (var annotation in GetAnnotations())
{
switch (annotation.Name)
{
case CoreAnnotationNames.MaxLength:
property.SetMaxLength((int?)annotation.Value);
break;
case CoreAnnotationNames.Unicode:
property.SetIsUnicode((bool?)annotation.Value);
break;
case CoreAnnotationNames.Precision:
property.SetPrecision((int?)annotation.Value);
break;
case CoreAnnotationNames.Scale:
property.SetScale((int?)annotation.Value);
break;
case CoreAnnotationNames.ProviderClrType:
property.SetProviderClrType((Type?)annotation.Value);
break;
case CoreAnnotationNames.ValueConverterType:
if (ClrType.UnwrapNullableType() == property.ClrType.UnwrapNullableType())
{
property.SetValueConverter((Type?)annotation.Value);
}
break;
case CoreAnnotationNames.ValueComparerType:
if (ClrType.UnwrapNullableType() == property.ClrType.UnwrapNullableType())
{
property.SetValueComparer((Type?)annotation.Value);
}
break;
default:
if (!CoreAnnotationNames.AllNames.Contains(annotation.Name))
{
property.SetAnnotation(annotation.Name, annotation.Value);
}
break;
}
}
}
public static QueryTypeBuilder <T> ProtectSensitiveInformation <T>(this QueryTypeBuilder <T> queryTypeBuilder) where T : class
{
foreach (PropertyInfo propertyInfo in typeof(T).GetProperties())
{
SensitiveInformationAttribute sensitiveInformationAttribute = propertyInfo.GetCustomAttributes <SensitiveInformationAttribute>().SingleOrDefault();
if (propertyInfo.DeclaringType == typeof(T) && sensitiveInformationAttribute != null)
{
IMutableProperty mutableProperty = queryTypeBuilder.Property(propertyInfo.Name).Metadata;
mutableProperty.SetValueConverter(SensitiveInformationConverter.Create(sensitiveInformationAttribute.KeyName));
}
}
return(queryTypeBuilder);
}
