/// <inheritdoc /> public override InternalEntityTypeBuilder Apply( InternalEntityTypeBuilder entityTypeBuilder, BsonKnownTypesAttribute bsonKnownTypesAttribute) { MongoDbEntityTypeAnnotations annotations = entityTypeBuilder.MongoDb(); if (!annotations.DiscriminatorIsRequired) { annotations.DiscriminatorIsRequired = entityTypeBuilder.Metadata.IsAbstract(); } if (bsonKnownTypesAttribute.KnownTypes != null) { InternalModelBuilder modelBuilder = entityTypeBuilder.ModelBuilder; Type baseType = entityTypeBuilder.Metadata.ClrType; foreach (Type derivedType in bsonKnownTypesAttribute.KnownTypes) { if (!baseType.IsAssignableFrom(derivedType)) { throw new InvalidOperationException($"Known type {derivedType} declared on base type {baseType} does not inherit from base type."); } modelBuilder .Entity(derivedType, ConfigurationSource.DataAnnotation) .MongoDb() .IsDerivedType = true; } } return(entityTypeBuilder); }
/// <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 InternalEntityTypeBuilder Apply(InternalEntityTypeBuilder entityTypeBuilder) { EntityType baseEntityType = Check.NotNull(entityTypeBuilder, nameof(entityTypeBuilder)).Metadata; IEnumerable <Type> knownTypes = baseEntityType.ClrType ?.GetTypeInfo() .GetCustomAttributes <BsonKnownTypesAttribute>(false) .SelectMany(bsonKnownTypeAttribute => bsonKnownTypeAttribute.KnownTypes) .ToList(); MongoDbEntityTypeAnnotations annotations = entityTypeBuilder.MongoDb(); if (!annotations.DiscriminatorIsRequired) { annotations.DiscriminatorIsRequired = baseEntityType.IsAbstract(); } if (knownTypes != null) { InternalModelBuilder modelBuilder = entityTypeBuilder.ModelBuilder; foreach (Type derivedType in knownTypes) { modelBuilder .Entity(derivedType, ConfigurationSource.DataAnnotation) .HasBaseType(baseEntityType, ConfigurationSource.DataAnnotation) .MongoDb() .IsDerivedType = true; } } return(entityTypeBuilder); }
public void Discriminator_is_type_name_by_default() { var model = new Model(); var entityType = new EntityType(typeof(RootType), model, ConfigurationSource.Explicit); var mongoDbEntityTypeAnnotations = new MongoDbEntityTypeAnnotations(entityType); Assert.Equal(typeof(RootType).Name, mongoDbEntityTypeAnnotations.Discriminator); }
public void Collection_name_is_pluralized_camel_cased_entity_type_by_default() { var model = new Model(); var entityType = new EntityType(typeof(RootType), model, ConfigurationSource.Explicit); var mongoDbEntityTypeAnnotations = new MongoDbEntityTypeAnnotations(entityType); Assert.Equal(MongoDbUtilities.Pluralize(MongoDbUtilities.ToCamelCase(nameof(RootType))), mongoDbEntityTypeAnnotations.CollectionName); }
/// <inheritdoc /> public virtual IMongoCollection <TEntity> GetCollection <TEntity>() { IEntityType collectionEntityType = _model .FindEntityType(typeof(TEntity)) .GetMongoDbCollectionEntityType(); MongoDbEntityTypeAnnotations annotations = collectionEntityType.MongoDb(); return(_mongoDatabase.GetCollection <TEntity>(annotations.CollectionName, annotations.CollectionSettings)); }
private IEntityType GetCollectionEntityType(IEntityType entityType) { MongoDbEntityTypeAnnotations annotations = entityType.MongoDb(); while (annotations.IsDerivedType && entityType.BaseType != null) { entityType = entityType.BaseType; annotations = entityType.MongoDb(); } return(entityType); }
public virtual IMongoCollection <TEntity> GetCollection <TEntity>() { var entityType = _model.FindEntityType(typeof(TEntity)); if (entityType.BaseType != null) { entityType = entityType.RootType(); } var annotations = new MongoDbEntityTypeAnnotations(entityType); return(_mongoDatabase.GetCollection <TEntity>(annotations.CollectionName, annotations.CollectionSettings)); }
/// <summary> /// Gets a <see cref="IMongoCollection{TEntity}"/> instance that can be used to store instances of <typeparamref name="TEntity"/>. /// </summary> /// <typeparam name="TEntity">The type of entity stored in the collection.</typeparam> /// <returns>The <see cref="IMongoCollection{TEntity}"/> instance that can store <typeparamref name="TEntity"/>.</returns> public virtual IMongoCollection <TEntity> GetCollection <TEntity>() { IEntityType entityType = _model.FindEntityType(typeof(TEntity)); MongoDbEntityTypeAnnotations annotations = entityType.MongoDb(); while (annotations.IsDerivedType && entityType.BaseType != null) { entityType = entityType.BaseType; annotations = entityType.MongoDb(); } return(_mongoDatabase.GetCollection <TEntity>(annotations.CollectionName, annotations.CollectionSettings)); }
public void Can_write_discriminator() { var discriminator = "discriminator"; var model = new Model(); var entityType = new EntityType(typeof(RootType), model, ConfigurationSource.Explicit); var mongoDbEntityTypeAnnotations = new MongoDbEntityTypeAnnotations(entityType) { Discriminator = discriminator }; Assert.Equal(discriminator, mongoDbEntityTypeAnnotations.Discriminator); }
public void Can_write_collection_name() { var collectionName = "myCollection"; var model = new Model(); var entityType = new EntityType(typeof(RootType), model, ConfigurationSource.Explicit); var mongoDbEntityTypeAnnotations = new MongoDbEntityTypeAnnotations(entityType) { CollectionName = collectionName }; Assert.Equal(collectionName, mongoDbEntityTypeAnnotations.CollectionName); }
private void ValidateDiscriminator(IEntityType entityType, ISet <Tuple <IEntityType, string> > discriminatorSet) { var annotations = new MongoDbEntityTypeAnnotations(entityType); if (string.IsNullOrWhiteSpace(annotations.Discriminator)) { throw new InvalidOperationException($"Missing discriminator value for entity type {entityType.DisplayName()}."); } if (!discriminatorSet.Add(Tuple.Create(entityType.RootType(), annotations.Discriminator))) { throw new InvalidOperationException($"Duplicate discriminator value {annotations.Discriminator} for root entity type {entityType.RootType().DisplayName()} (defined on {entityType.DisplayName()})."); } }
public MongoDbDocumentBuilder([NotNull] InternalEntityTypeBuilder internalEntityTypeBuilder, ConfigurationSource configurationSource) { Check.NotNull(internalEntityTypeBuilder, nameof(internalEntityTypeBuilder)); if (!Enum.IsDefined(typeof(ConfigurationSource), configurationSource)) { throw new ArgumentOutOfRangeException(nameof(configurationSource), $"{configurationSource} is not a valid {nameof(Microsoft.EntityFrameworkCore.Metadata.Internal.ConfigurationSource)} value."); } InternalEntityTypeBuilder = internalEntityTypeBuilder; ConfigurationSource = configurationSource; MongoDbEntityTypeAnnotations = new MongoDbEntityTypeAnnotations(internalEntityTypeBuilder.Metadata); }
/// <inheritdoc /> public Expression CreateDocumentQueryExpression(IEntityType entityType) { MongoDbEntityTypeAnnotations annotations = Check.NotNull(entityType, nameof(entityType)).MongoDb(); IEntityType queryEntityType = entityType; if (!entityType.IsDocumentRootEntityType()) { entityType = entityType.GetMongoDbCollectionEntityType(); } Expression queryExpression = Expression.Call( Expression.Constant(_mongoDbConnection.GetDatabase()), GetCollectionMethodInfo.MakeGenericMethod(entityType.ClrType), new Expression[] { Expression.Constant(annotations.CollectionName), Expression.Constant( annotations.CollectionSettings, typeof(MongoCollectionSettings)) }); queryExpression = Expression.Call( null, AsQueryableMethodInfo.MakeGenericMethod(entityType.ClrType), new [] { queryExpression, Expression.Constant( null, typeof(AggregateOptions)) }); if (queryEntityType != entityType) { queryExpression = Expression.Call( queryExpression, OfTypeMethodInfo.MakeGenericMethod(queryEntityType.ClrType)); } return(queryExpression); }
/// <inheritdoc /> protected override Expression VisitEntityQueryable(Type elementType) { Check.NotNull(elementType, nameof(elementType)); IEntityType entityType = QueryModelVisitor.QueryCompilationContext.FindEntityType(_querySource) ?? _model.FindEntityType(elementType); MongoDbEntityTypeAnnotations annotations = entityType.MongoDb(); while (annotations.IsDerivedType && entityType.BaseType != null) { entityType = entityType.BaseType; annotations = entityType.MongoDb(); } return(Expression.Call( entityType.ClrType == elementType ? EntityQueryMethodInfo.MakeGenericMethod(elementType) : SubEntityQueryMethodInfo.MakeGenericMethod(entityType.ClrType, elementType), EntityQueryModelVisitor.QueryContextParameter)); }
/// <inheritdoc /> public override InternalEntityTypeBuilder Apply(InternalEntityTypeBuilder entityTypeBuilder, BsonDiscriminatorAttribute attribute) { Check.NotNull(entityTypeBuilder, nameof(entityTypeBuilder)); Check.NotNull(attribute, nameof(attribute)); MongoDbEntityTypeAnnotations annotations = entityTypeBuilder.MongoDb(); if (!string.IsNullOrWhiteSpace(attribute.Discriminator)) { annotations.Discriminator = attribute.Discriminator; } if (!annotations.DiscriminatorIsRequired) { annotations.DiscriminatorIsRequired = attribute.Required; } annotations.IsRootType = attribute.RootClass; return(entityTypeBuilder); }