/// <summary> /// Figures out the key properties and marks them as Keys in the EDM model. /// </summary> /// <param name="entity">The entity type being configured.</param> /// <param name="model">The <see cref="ODataModelBuilder"/>.</param> public override void Apply(EntityTypeConfiguration entity, ODataConventionModelBuilder model) { if (entity == null) { throw Error.ArgumentNull("entity"); } // Suppress the EntityKeyConvention if there is any key in EntityTypeConfiguration. if (entity.Keys.Any() || entity.EnumKeys.Any()) { return; } // Suppress the EntityKeyConvention if base type has any key. if (entity.BaseType != null && entity.BaseType.Keys().Any()) { return; } PropertyConfiguration key = GetKeyProperty(entity); if (key != null) { entity.HasKey(key.PropertyInfo); } }
public NhsContext(EntityTypeConfiguration<Person> personTypeConfiguration, EntityTypeConfiguration<Colour> colourTypeConfiguration) : base("name=NhsContext") { _personTypeConfiguration = personTypeConfiguration; _colourTypeConfiguration = colourTypeConfiguration; }
public void RegTo(ConfigurationRegistrar confRegistrar) { var r = new EntityTypeConfiguration<UserInfo>(); r.ToTable("UserInfo"); r.HasKey(p => p.AutoId); confRegistrar.Add<UserInfo>(r); }
public override void Apply(EntityTypeConfiguration entity, ODataModelBuilder model) { if (entity.IsAbstract == null) { entity.IsAbstract = entity.ClrType.IsAbstract; } }
public void Can_get_and_set_table_name() { var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); entityTypeConfiguration.ToTable("Foo"); Assert.Equal("Foo", entityTypeConfiguration.GetTableName().Name); }
private static NavigationSourceConfiguration GetDefaultNavigationSource(EntityTypeConfiguration targetEntityType, ODataModelBuilder model, bool isSingleton) { if (targetEntityType == null) { return null; } NavigationSourceConfiguration[] matchingNavigationSources = null; if (isSingleton) { matchingNavigationSources = model.Singletons.Where(e => e.EntityType == targetEntityType).ToArray(); } else { matchingNavigationSources = model.EntitySets.Where(e => e.EntityType == targetEntityType).ToArray(); } if (matchingNavigationSources.Length > 1) { return null; } else if (matchingNavigationSources.Length == 1) { return matchingNavigationSources[0]; } else { // default navigation source is the same as the default navigation source for the base type. return GetDefaultNavigationSource(targetEntityType.BaseType as EntityTypeConfiguration, model, isSingleton); } }
/// <summary> /// Constructor. /// </summary> /// <param name="nameChanges"></param> internal ExpressionTranslator(EntityTypeConfiguration configuration) { //_nameChanges = nameChanges; _configuration = configuration; _nameChanges = configuration.KeyMappings; _constantEvaluator = new ExpressionEvaluator(); }
/// <summary>Defines the mapping information for the entity 'ApiDataSource'</summary> /// <param name="config">The configuration to modify.</param> protected virtual void MapApiDataSource(EntityTypeConfiguration<ApiDataSource> config) { config.ToTable("ApiDataSource"); config.HasKey(t => t.Id); config.Property(t => t.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity); config.Property(t => t.SourceName).HasMaxLength(50).IsRequired(); config.Property(t => t.SourceBaseUrl).HasMaxLength(200); }
public void Configure_should_set_configuration() { var entityType = new EdmEntityType { Name = "E" }; var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); entityTypeConfiguration.Configure(entityType, new EdmModel()); Assert.Same(entityTypeConfiguration, entityType.GetConfiguration()); }
public void Configure_should_throw_when_property_not_found() { var entityType = new EdmEntityType { Name = "E" }; var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); var mockPropertyConfiguration = new Mock<PrimitivePropertyConfiguration>(); entityTypeConfiguration.Property(new PropertyPath(new MockPropertyInfo()), () => mockPropertyConfiguration.Object); Assert.Equal(Strings.PropertyNotFound(("P"), "E"), Assert.Throws<InvalidOperationException>(() => entityTypeConfiguration.Configure(entityType, new EdmModel())).Message); }
public void GetTableName_returns_current_TableName() { var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); Assert.Equal(null, entityTypeConfiguration.GetTableName()); entityTypeConfiguration.ToTable("Foo"); Assert.Equal("Foo", entityTypeConfiguration.GetTableName().Name); }
public void Add_entity_configuration_should_add_to_model_configuration() { var modelConfiguration = new ModelConfiguration(); var entityConfiguration = new EntityTypeConfiguration<object>(); new ConfigurationRegistrar(modelConfiguration).Add(entityConfiguration); Assert.Same(entityConfiguration.Configuration, modelConfiguration.Entity(typeof(object))); }
internal static void Define(EntityTypeConfiguration<Domain.ItemInstance> config) { config.HasRequired(r => r.Item) .WithMany(r => r.OwnedBy) .HasForeignKey(fk => fk.ItemId) .WillCascadeOnDelete(false); config.HasRequired(r => r.Owner) .WithMany(r => r.Items) .HasForeignKey(fk => fk.OwnerId) .WillCascadeOnDelete(false); }
internal static void Define(EntityTypeConfiguration<Domain.Transaction> config) { config.HasOptional(p => p.CreditedUser) .WithMany(r => r.Credits) .HasForeignKey(fk => fk.CreditedUserId); config.HasOptional(p => p.DebitedUser) .WithMany(r => r.Debits) .HasForeignKey(fk => fk.DebitedUserId); config.Property(p => p.Amount).HasPrecision(19, 4); }
/// <summary>Defines the mapping information for the entity 'MovieNotFound'</summary> /// <param name="config">The configuration to modify.</param> protected virtual void MapMovieNotFound(EntityTypeConfiguration<MovieNotFound> config) { config.ToTable("MovieNotFound"); config.HasKey(t => new { t.ItemId, t.ItemSource }); config.Property(t => t.ItemId).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None); config.Property(t => t.ItemSource).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None); config.Property(t => t.RowId).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity).IsRequired(); config.Property(t => t.ItemSearchTitle).HasMaxLength(100); config.Property(t => t.ItemSearchYear); config.Property(t => t.AddedOn); config.Property(t => t.ChangedOn); }
public void Configure_should_configure_entity_set_name() { var model = new EdmModel().Initialize(); var entityType = new EdmEntityType { Name = "E" }; var entitySet = model.AddEntitySet("ESet", entityType); var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)) { EntitySetName = "MySet" }; entityTypeConfiguration.Configure(entityType, model); Assert.Equal("MySet", entitySet.Name); Assert.Same(entityTypeConfiguration, entitySet.GetConfiguration()); }
private static IEnumerable<IMethodTranslator> GetTranslators(EntityTypeConfiguration configuration) { return new List<IMethodTranslator> { new WhereTranslator(configuration), new FirstTranslator(configuration), new FirstOrDefaultTranslator(configuration), new SingleTranslator(configuration), new SingleOrDefaultTranslator(configuration), new SelectTranslator(configuration.KeyMappings), new TakeTranslator() }; }
private static PropertyConfiguration GetKeyProperty(EntityTypeConfiguration entityType) { IEnumerable<PropertyConfiguration> keys = entityType.Properties .Where(p => (p.Name.Equals(entityType.Name + "Id", StringComparison.OrdinalIgnoreCase) || p.Name.Equals("Id", StringComparison.OrdinalIgnoreCase)) && EdmLibHelpers.GetEdmPrimitiveTypeOrNull(p.PropertyInfo.PropertyType) != null); if (keys.Count() == 1) { return keys.Single(); } return null; }
private EntityTypeConfiguration<HandlerRecord> HandlerInfoConfiguration() { var config = new EntityTypeConfiguration<HandlerRecord>(); config.HasKey(handler => new { handler.MessageId, handler.MessageTypeCode, handler.HandlerTypeCode }); config.Property(handler => handler.MessageId).IsRequired().HasColumnType("char").HasMaxLength(36); config.Property(handler => handler.MessageTypeCode).IsRequired().HasColumnType("int"); config.Property(handler => handler.HandlerTypeCode).HasColumnType("int"); config.Property(handler => handler.Timestamp).HasColumnName("OnCreated").HasColumnType("datetime"); config.ToTable("thinknet_handlers"); return config; }
/// <summary> /// Configure LongShortUrlUser entityTypeConfiguration /// </summary> /// <param name="modelBuilder"></param> private static void configureEntity(EntityTypeConfiguration<LongShortUrlUser> entityTypeConfiguration) { entityTypeConfiguration.HasKey(e => e.Id); entityTypeConfiguration.Property(e => e.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity); entityTypeConfiguration.Property(e => e.LongShortUrlId).IsRequired(); entityTypeConfiguration.Property(e => e.IpAddress).IsRequired().HasMaxLength(45); entityTypeConfiguration.Property(e => e.UserAgent).IsRequired(); entityTypeConfiguration.Property(e => e.CreatedDate).IsRequired(); }
private EntityTypeConfiguration<Snapshot> SnapshotConfiguration() { var config = new EntityTypeConfiguration<Snapshot>(); config.HasKey(snapshot => new { snapshot.AggregateRootId, snapshot.AggregateRootTypeCode }); config.Property(snapshot => snapshot.AggregateRootId).IsRequired().HasColumnType("char").HasMaxLength(36); config.Property(snapshot => snapshot.AggregateRootTypeCode).IsRequired().HasColumnType("int"); config.Property(snapshot => snapshot.Version).HasColumnType("int"); config.Property(snapshot => snapshot.Data).HasColumnType("varchar"); config.Property(snapshot => snapshot.Timestamp).HasColumnName("OnCreated").HasColumnType("datetime"); config.ToTable("thinknet_snapshots"); return config; }
public void Configure_should_configure_properties() { var entityType = new EdmEntityType { Name = "E" }; var property = entityType.AddPrimitiveProperty("P"); property.PropertyType.EdmType = EdmPrimitiveType.Int32; var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); var mockPropertyConfiguration = new Mock<PrimitivePropertyConfiguration>(); var mockPropertyInfo = new MockPropertyInfo(); property.SetClrPropertyInfo(mockPropertyInfo); entityTypeConfiguration.Property(new PropertyPath(mockPropertyInfo), () => mockPropertyConfiguration.Object); entityTypeConfiguration.Configure(entityType, new EdmModel()); mockPropertyConfiguration.Verify(p => p.Configure(property)); }
public void TimestampConvention_AppliesWhenTheAttributeIsAppliedToASingleProperty() { // Arrange PropertyInfo property = CreateMockPropertyInfo("TestProperty"); EntityTypeConfiguration entityType = new EntityTypeConfiguration(); PrimitivePropertyConfiguration primitiveProperty = new PrimitivePropertyConfiguration(property, entityType); entityType.ExplicitProperties.Add(property, primitiveProperty); TimestampAttributeEdmPropertyConvention convention = new TimestampAttributeEdmPropertyConvention(); // Act convention.Apply(primitiveProperty, entityType); // Assert Assert.True(primitiveProperty.ConcurrencyToken); }
private EntityTypeConfiguration<Event> EventDataConfiguration() { var config = new EntityTypeConfiguration<Event>(); config.HasKey(@event => new { @event.AggregateRootId, @event.AggregateRootTypeCode, @event.Version }); config.Property(@event => @event.AggregateRootId).IsRequired().HasColumnType("char").HasMaxLength(36); config.Property(@event => @event.AggregateRootTypeCode).IsRequired().HasColumnType("int"); config.Property(@event => @event.Version).HasColumnType("int"); config.Property(@event => @event.CorrelationId).HasColumnType("char").HasMaxLength(36); config.Property(@event => @event.Payload).HasColumnType("varchar"); config.Property(@event => @event.Timestamp).HasColumnName("OnCreated").HasColumnType("datetime"); config.ToTable("thinknet_events"); return config; }
public void TimestampConvention_DoesntApplyWhenTheAttributeIsAppliedToMultipleProperties() { // Arrange PropertyInfo property = CreateMockPropertyInfo("TestProperty"); PropertyInfo otherProperty = CreateMockPropertyInfo("OtherTestProperty"); EntityTypeConfiguration entityType = new EntityTypeConfiguration(); PrimitivePropertyConfiguration primitiveProperty = new PrimitivePropertyConfiguration(property, entityType); entityType.ExplicitProperties.Add(property, primitiveProperty); entityType.ExplicitProperties.Add(otherProperty, new PrimitivePropertyConfiguration(otherProperty, entityType)); TimestampAttributeEdmPropertyConvention convention = new TimestampAttributeEdmPropertyConvention(); // Act convention.Apply(primitiveProperty, entityType); // Assert Assert.False(primitiveProperty.ConcurrencyToken); }
protected void buildCustomers(EntityTypeConfiguration<Customer> customerEntity) { customerEntity .HasKey(x => x.customerID) .Property(x => x.name).IsRequired() .HasMaxLength(50); customerEntity .HasMany(x => x.orders) .WithRequired(x => x.customer) .HasForeignKey(x => x.customerID) .WillCascadeOnDelete(); customerEntity .Property(x => x.timeStamp) .IsRequired(); }
/// <summary> /// Figures out the key properties and marks them as Keys in the EDM model. /// </summary> /// <param name="entity">The entity type being configured.</param> /// <param name="model">The <see cref="ODataModelBuilder"/>.</param> public override void Apply(EntityTypeConfiguration entity, ODataModelBuilder model) { if (entity == null) { throw Error.ArgumentNull("entity"); } // Try to figure out keys only if there is no base type. if (entity.BaseType == null) { PropertyConfiguration key = GetKeyProperty(entity); if (key != null) { entity.HasKey(key.PropertyInfo); } } }
public void TimestampConvention_DoesntApplyWhenTheAttributeIsAppliedToMultipleProperties_InATypeHierarchy() { // Arrange PropertyInfo property = CreateMockPropertyInfo("TestProperty"); PropertyInfo otherProperty = CreateMockPropertyInfo("OtherTestProperty"); EntityTypeConfiguration baseEntityType = new EntityTypeConfiguration(); EntityTypeConfiguration entityType = new Mock<EntityTypeConfiguration>().SetupAllProperties().Object; entityType.BaseType = baseEntityType; PrimitivePropertyConfiguration primitiveProperty = new PrimitivePropertyConfiguration(property, entityType); entityType.ExplicitProperties.Add(property, primitiveProperty); baseEntityType.ExplicitProperties.Add(otherProperty, new PrimitivePropertyConfiguration(otherProperty, baseEntityType)); TimestampAttributeEdmPropertyConvention convention = new TimestampAttributeEdmPropertyConvention(); // Act convention.Apply(primitiveProperty, entityType, new ODataConventionModelBuilder()); // Assert Assert.False(primitiveProperty.ConcurrencyToken); }
/// <summary> /// Configure LongShortUrl entityTypeConfiguration /// </summary> /// <param name="modelBuilder"></param> private static void configureEntity(EntityTypeConfiguration<LongShortUrl> entityTypeConfiguration) { entityTypeConfiguration.HasKey(e => e.Id); entityTypeConfiguration.Property(e => e.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity); entityTypeConfiguration.Property(e => e.ShortUrlId).IsRequired().HasMaxLength(10); entityTypeConfiguration.Property(e => e.LongUrl).IsRequired().HasMaxLength(2000); entityTypeConfiguration.Property(e => e.CreatedDate).IsRequired(); entityTypeConfiguration .HasMany(e => e.LongShortUrlUsers) .WithOptional() .HasForeignKey(e => e.LongShortUrlId) .WillCascadeOnDelete(); }
/// <summary>Defines the mapping information for the entity 'MovieCreditResult'</summary> /// <param name="config">The configuration to modify.</param> protected virtual void MapMovieCreditResult(EntityTypeConfiguration<MovieCreditResult> config) { config.ToTable("MovieCreditResult"); config.HasKey(t => new { t.ItemId, t.RowId }); config.Property(t => t.ItemId).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None); config.Property(t => t.RowId).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity); config.Property(t => t.ItemSearchTitle).HasMaxLength(100); config.Property(t => t.ApiUrl).HasMaxLength(200); config.Property(t => t.ResultNum); config.Property(t => t.Name).HasMaxLength(100); config.Property(t => t.Order); config.Property(t => t.CastId).HasColumnName("Cast_Id"); config.Property(t => t.Character).HasMaxLength(100); config.Property(t => t.CreditId).HasColumnName("Credit_Id").HasMaxLength(50); config.Property(t => t.TmdId); config.Property(t => t.ProfilePath).HasColumnName("Profile_Path").HasMaxLength(200); config.Property(t => t.AddedOn); config.Property(t => t.ChangedOn); }
public static IEdmModel GetEdmModel(WebRouteConfiguration configuration) { ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder(); EntitySetConfiguration <Employee> entitySetConfiguration = builder.EntitySet <Employee>("Employees"); EntityTypeConfiguration <Manager> entityTypeConfigurationOfManager = builder.EntityType <Manager>(); EntityTypeConfiguration <Employee> entityTypeConfigurationOfEmployee = builder.EntityType <Employee>(); #region functions // Function bound to a collection of base EntityType. entityTypeConfigurationOfEmployee.Collection.Function("GetCount") .Returns <int>(); // Overload entityTypeConfigurationOfEmployee.Collection.Function("GetCount") .Returns <int>() .Parameter <string>("Name"); // Overload with one optional parameter var salaryRangeCount = entityTypeConfigurationOfEmployee.Collection.Function("GetWholeSalary") .Returns <int>(); salaryRangeCount.Parameter <double>("minSalary"); salaryRangeCount.Parameter <double>("maxSalary").Optional(); salaryRangeCount.Parameter <double>("aveSalary").HasDefaultValue("8.9"); // Function bound to a collection of derived EntityType. entityTypeConfigurationOfManager.Collection.Function("GetCount") .Returns <int>(); // Function bound to an base EntityType entityTypeConfigurationOfEmployee.Function("GetEmailsCount") .Returns <int>(); entityTypeConfigurationOfEmployee.Function("GetOptionalAddresses") .ReturnsCollection <Address>() .IsComposable = true; entityTypeConfigurationOfEmployee.Function("GetEmails") .ReturnsCollection <string>() .IsComposable = false; // Function bound to a derived EntityType entityTypeConfigurationOfManager.Function("GetEmailsCount") .Returns <int>(); // Function with primitive and collection of primitive parameters var function = entityTypeConfigurationOfEmployee.Collection.Function("PrimitiveFunction").Returns <string>(); function.Parameter <int>("param"); function.Parameter <double?>("price"); // nullable function.Parameter <string>("name"); // nullable function.CollectionParameter <string>("names"); // collection with nullable element // Function with Enum and collection of Enum parameters function = entityTypeConfigurationOfEmployee.Collection.Function("EnumFunction").Returns <string>(); function.Parameter <Color>("bkColor"); function.Parameter <Color?>("frColor"); // nullable function.CollectionParameter <Color>("colors"); // collection with non-nullable element // Function with complex and collection of complex parameters function = entityTypeConfigurationOfEmployee.Collection.Function("ComplexFunction").ReturnsCollection <Address>(); function.Parameter <Address>("address").Nullable = false; function.Parameter <Address>("location"); // nullable function.CollectionParameter <Address>("addresses"); // collection with nullable element // Function with entity and collection of entity parameters function = entityTypeConfigurationOfEmployee.Collection.Function("EntityFunction").Returns <string>(); function.EntityParameter <Employee>("person").Nullable = false; function.EntityParameter <Employee>("guard"); // nullable function.CollectionEntityParameter <Employee>("staff"); // collection with nullable element #endregion #region actions // Action bound to a collection of base EntityType entityTypeConfigurationOfEmployee.Collection.Action("IncreaseSalary") .ReturnsCollectionFromEntitySet(entitySetConfiguration) .Parameter <string>("Name"); // Action bound to a collection of derived EntityType entityTypeConfigurationOfManager.Collection.Action("IncreaseSalary") .ReturnsCollectionFromEntitySet(entitySetConfiguration) .Parameter <string>("Name"); // Action bound to a base EntityType entityTypeConfigurationOfEmployee.Action("IncreaseSalary") .Returns <int>(); // Action bound to a derived EntityType entityTypeConfigurationOfManager.Action("IncreaseSalary") .Returns <int>(); // Action with optional parameters var action = entityTypeConfigurationOfManager.Action("IncreaseWholeSalary") .Returns <int>(); action.Parameter <double>("minSalary"); action.Parameter <double>("maxSalary").Optional(); action.Parameter <double>("aveSalary").HasDefaultValue("8.9"); // Action with primitive and collection of primitive parameters action = entityTypeConfigurationOfEmployee.Collection.Action("PrimitiveAction"); action.Parameter <int>("param"); action.Parameter <double?>("price"); // nullable action.Parameter <string>("name"); // nullable action.CollectionParameter <string>("names"); // collection with nullable element // Action with Enum and collection of Enum parameters action = entityTypeConfigurationOfEmployee.Collection.Action("EnumAction"); action.Parameter <Color>("bkColor"); action.Parameter <Color?>("frColor"); // nullable action.CollectionParameter <Color>("colors"); // collection with non-nullable element // Action with complex and collection of complex parameters action = entityTypeConfigurationOfEmployee.Collection.Action("ComplexAction"); action.Parameter <Address>("address").Nullable = false; action.Parameter <Address>("location"); // nullable action.CollectionParameter <Address>("addresses"); // collection with nullable element // Action with entity and collection of entity parameters action = entityTypeConfigurationOfEmployee.Collection.Action("EntityAction"); action.EntityParameter <Employee>("person").Nullable = false; action.EntityParameter <Employee>("guard"); // nullable action.CollectionEntityParameter <Employee>("staff"); // collection with nullable element #endregion builder.Action("ResetDataSource"); builder.EnumType <Color>().Namespace = "NS"; builder.ComplexType <Address>().Namespace = "NS"; builder.ComplexType <SubAddress>().Namespace = "NS"; builder.EntityType <Employee>().Namespace = "NS"; builder.EntityType <Manager>().Namespace = "NS"; return(builder.GetEdmModel()); }
internal override void Configure( AssociationType associationType, AssociationEndMember dependentEnd, EntityTypeConfiguration entityTypeConfiguration) { DebugCheck.NotNull(associationType); DebugCheck.NotNull(dependentEnd); DebugCheck.NotNull(entityTypeConfiguration); if (!_dependentProperties.Any()) { return; } var dependentPropertInfos = _dependentProperties.AsEnumerable(); if (!IsFullySpecified) { var foreignKeys = from p in _dependentProperties select new { PropertyInfo = p, entityTypeConfiguration.Property(new PropertyPath(p)).ColumnOrder }; if ((_dependentProperties.Count > 1) && foreignKeys.Any(p => !p.ColumnOrder.HasValue)) { var dependentKeys = dependentEnd.GetEntityType().KeyProperties; if ((dependentKeys.Count == _dependentProperties.Count) && foreignKeys.All(fk => dependentKeys.Any(p => p.GetClrPropertyInfo().IsSameAs(fk.PropertyInfo)))) { // The FK and PK sets are equal, we know the order dependentPropertInfos = dependentKeys.Select(p => p.GetClrPropertyInfo()); } else { throw Error.ForeignKeyAttributeConvention_OrderRequired(entityTypeConfiguration.ClrType); } } else { dependentPropertInfos = foreignKeys.OrderBy(p => p.ColumnOrder).Select(p => p.PropertyInfo); } } var dependentProperties = new List <EdmProperty>(); foreach (var dependentProperty in dependentPropertInfos) { var property = dependentEnd.GetEntityType() .GetDeclaredPrimitiveProperty(dependentProperty); if (property == null) { throw Error.ForeignKeyPropertyNotFound( dependentProperty.Name, dependentEnd.GetEntityType().Name); } dependentProperties.Add(property); } var principalEnd = associationType.GetOtherEnd(dependentEnd); var associationConstraint = new ReferentialConstraint( principalEnd, dependentEnd, principalEnd.GetEntityType().KeyProperties, dependentProperties); if (principalEnd.IsRequired()) { associationConstraint.ToProperties.Each(p => p.Nullable = false); } associationType.Constraint = associationConstraint; }
/// <summary> /// Extension method for map private navigation property /// <example> /// modelBuilder.Entity<Customer>() /// .HasMany<Customer, Order>("Orders"); /// </example> /// </summary> /// <typeparam name="TEntityType">The type of principal entity</typeparam> /// <typeparam name="TTargetEntityType">The type of target entity (without ICollection{})</typeparam> /// <param name="entityConfiguration">Associated EntityTypeConfiguration</param> /// <param name="navigationPropertyName">The navigation property name</param> /// <returns>The ManyNavigationPropertyConfiguration for this map</returns> public static ManyNavigationPropertyConfiguration <TEntityType, TTargetEntityType> HasMany <TEntityType, TTargetEntityType>(this EntityTypeConfiguration <TEntityType> entityConfiguration, string navigationPropertyName) where TEntityType : class where TTargetEntityType : class { var propertyInfo = typeof(TEntityType).GetProperty(navigationPropertyName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public); if (propertyInfo != null) // if private property exists { ParameterExpression arg = Expression.Parameter(typeof(TEntityType), "parameterName"); MemberExpression memberExpression = Expression.Property((Expression)arg, propertyInfo); //Create the expression to map Expression <Func <TEntityType, ICollection <TTargetEntityType> > > expression = (Expression <Func <TEntityType, ICollection <TTargetEntityType> > >)Expression.Lambda(memberExpression, arg); return(entityConfiguration.HasMany <TTargetEntityType>(expression)); } else { throw new InvalidOperationException("The property not exist"); } }
public TreeTypeBuilder(EntityTypeConfiguration <TreeType> entity) { entity.Property(p => p.Name).IsRequired().HasMaxLength(200); entity.Property(p => p.Photo).IsRequired().HasMaxLength(200); entity.HasMany(t => t.Regions).WithMany(r => r.TreeTypes); }
private static IEdmModel GetModel() { var config = RoutingConfigurationFactory.CreateWithTypes(typeof(Customer)); ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create(config); builder.ContainerName = "C"; builder.Namespace = "A.B"; EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType; // bound actions ActionConfiguration primitive = customer.Action("Primitive"); primitive.Parameter <int>("Quantity"); primitive.Parameter <string>("ProductCode"); primitive.Parameter <Date>("Birthday"); primitive.Parameter <AColor>("BkgColor"); primitive.Parameter <AColor?>("InnerColor"); ActionConfiguration complex = customer.Action("Complex"); complex.Parameter <int>("Quantity"); complex.Parameter <MyAddress>("Address"); ActionConfiguration enumType = customer.Action("Enum"); enumType.Parameter <AColor>("Color"); ActionConfiguration primitiveCollection = customer.Action("PrimitiveCollection"); primitiveCollection.Parameter <string>("Name"); primitiveCollection.CollectionParameter <int>("Ratings"); primitiveCollection.CollectionParameter <TimeOfDay>("Time"); primitiveCollection.CollectionParameter <AColor?>("Colors"); ActionConfiguration complexCollection = customer.Action("ComplexCollection"); complexCollection.Parameter <string>("Name"); complexCollection.CollectionParameter <MyAddress>("Addresses"); ActionConfiguration enumCollection = customer.Action("EnumCollection"); enumCollection.CollectionParameter <AColor>("Colors"); ActionConfiguration entity = customer.Action("Entity"); entity.Parameter <int>("Id"); entity.EntityParameter <Customer>("Customer"); entity.EntityParameter <Customer>("NullableCustomer"); ActionConfiguration entityCollection = customer.Action("EntityCollection"); entityCollection.Parameter <int>("Id"); entityCollection.CollectionEntityParameter <Customer>("Customers"); // unbound actions ActionConfiguration unboundPrimitive = builder.Action("UnboundPrimitive"); unboundPrimitive.Parameter <int>("Quantity"); unboundPrimitive.Parameter <string>("ProductCode"); unboundPrimitive.Parameter <Date>("Birthday"); unboundPrimitive.Parameter <AColor>("BkgColor"); unboundPrimitive.Parameter <AColor?>("InnerColor"); ActionConfiguration unboundComplex = builder.Action("UnboundComplex"); unboundComplex.Parameter <int>("Quantity"); unboundComplex.Parameter <MyAddress>("Address"); ActionConfiguration unboundEnum = builder.Action("UnboundEnum"); unboundEnum.Parameter <AColor>("Color"); ActionConfiguration unboundPrimitiveCollection = builder.Action("UnboundPrimitiveCollection"); unboundPrimitiveCollection.Parameter <string>("Name"); unboundPrimitiveCollection.CollectionParameter <int>("Ratings"); unboundPrimitiveCollection.CollectionParameter <TimeOfDay>("Time"); unboundPrimitiveCollection.CollectionParameter <AColor?>("Colors"); ActionConfiguration unboundComplexCollection = builder.Action("UnboundComplexCollection"); unboundComplexCollection.Parameter <string>("Name"); unboundComplexCollection.CollectionParameter <MyAddress>("Addresses"); ActionConfiguration unboundEnumCollection = builder.Action("UnboundEnumCollection"); unboundEnumCollection.CollectionParameter <AColor>("Colors"); ActionConfiguration unboundEntity = builder.Action("UnboundEntity"); unboundEntity.Parameter <int>("Id"); unboundEntity.EntityParameter <Customer>("Customer").Nullable = false; unboundEntity.EntityParameter <Customer>("NullableCustomer"); ActionConfiguration unboundEntityCollection = builder.Action("UnboundEntityCollection"); unboundEntityCollection.Parameter <int>("Id"); unboundEntityCollection.CollectionEntityParameter <Customer>("Customers"); return(builder.GetEdmModel()); }
public static void AddConfiguration <TEntity>( this ModelBuilder modelBuilder, EntityTypeConfiguration <TEntity> entityConfiguration) where TEntity : class { modelBuilder.Entity <TEntity>(entityConfiguration.Configure); }
public void CanBuildBoundOperationCacheForIEdmModel() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType; customer.HasKey(c => c.ID); customer.Property(c => c.Name); customer.ComplexProperty(c => c.Address); EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType; movie.HasKey(m => m.ID); movie.HasKey(m => m.Name); EntityTypeConfiguration <Blockbuster> blockBuster = builder.EntityType <Blockbuster>().DerivesFrom <Movie>(); EntityTypeConfiguration movieConfiguration = builder.StructuralTypes.OfType <EntityTypeConfiguration>().Single(t => t.Name == "Movie"); // build actions that are bindable to a single entity customer.Action("InCache1_CustomerAction"); customer.Action("InCache2_CustomerAction"); movie.Action("InCache3_MovieAction"); ActionConfiguration incache4_MovieAction = builder.Action("InCache4_MovieAction"); incache4_MovieAction.SetBindingParameter("bindingParameter", movieConfiguration); blockBuster.Action("InCache5_BlockbusterAction"); // build actions that are either: bindable to a collection of entities, have no parameter, have only complex parameter customer.Collection.Action("NotInCache1_CustomersAction"); movie.Collection.Action("NotInCache2_MoviesAction"); ActionConfiguration notInCache3_NoParameters = builder.Action("NotInCache3_NoParameters"); ActionConfiguration notInCache4_AddressParameter = builder.Action("NotInCache4_AddressParameter"); notInCache4_AddressParameter.Parameter <Address>("address"); IEdmModel model = builder.GetEdmModel(); IEdmEntityType customerType = model.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "Customer"); IEdmEntityType movieType = model.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "Movie"); IEdmEntityType blockBusterType = model.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "Blockbuster"); // Act BindableOperationFinder annotation = new BindableOperationFinder(model); IEdmAction[] movieActions = annotation.FindOperations(movieType) .OfType <IEdmAction>() .ToArray(); IEdmAction[] customerActions = annotation.FindOperations(customerType) .OfType <IEdmAction>() .ToArray(); IEdmAction[] blockBusterActions = annotation.FindOperations(blockBusterType) .OfType <IEdmAction>() .ToArray(); // Assert Assert.Equal(2, customerActions.Length); Assert.NotNull(customerActions.SingleOrDefault(a => a.Name == "InCache1_CustomerAction")); Assert.NotNull(customerActions.SingleOrDefault(a => a.Name == "InCache2_CustomerAction")); Assert.Equal(2, movieActions.Length); Assert.NotNull(movieActions.SingleOrDefault(a => a.Name == "InCache3_MovieAction")); Assert.NotNull(movieActions.SingleOrDefault(a => a.Name == "InCache4_MovieAction")); Assert.Equal(3, blockBusterActions.Length); Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache3_MovieAction")); Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache4_MovieAction")); Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache5_BlockbusterAction")); }
public SectorBuilder(EntityTypeConfiguration <Sector> builder) { builder.Property(b => b.Name).HasMaxLength(50).IsRequired(); }
public EntityTypeConfigurationWrapper(EntityTypeConfiguration <TEntity> entityTypeConfiguration) { this.entityTypeConfiguration = entityTypeConfiguration; }
protected virtual void ExtendKeyIDWithOtherConfigurations(EntityTypeConfiguration <TEntity> entityConfig) { }
protected override void OnModelCreating(DbModelBuilder modelBuilder) { if (modelBuilder == null) { throw new ArgumentNullException("modelBuilder"); } // Keep this: modelBuilder.Entity <IdentityUser>().ToTable("AspNetUsers"); // Change TUser to ApplicationUser everywhere else - IdentityUser // and ApplicationUser essentially 'share' the AspNetUsers Table in the database: EntityTypeConfiguration <ApplicationUser> table = modelBuilder.Entity <ApplicationUser>().ToTable("AspNetUsers"); table.Property((ApplicationUser u) => u.UserName).IsRequired(); // EF won't let us swap out IdentityUserRole for ApplicationUserRole here: modelBuilder.Entity <ApplicationUser>() .HasMany <IdentityUserRole>((ApplicationUser u) => u.Roles); modelBuilder.Entity <IdentityUserRole>() .HasKey((IdentityUserRole r) => new { UserId = r.UserId, RoleId = r.RoleId }).ToTable("AspNetUserRoles"); // Add the group stuff here: modelBuilder.Entity <ApplicationUser>() .HasMany <ApplicationUserGroup>((ApplicationUser u) => u.Groups); modelBuilder.Entity <ApplicationUserGroup>() .HasKey((ApplicationUserGroup r) => new { UserId = r.UserId, GroupId = r.GroupId }).ToTable("ApplicationUserGroups"); // And here: modelBuilder.Entity <Group>() .HasMany <ApplicationRoleGroup>((Group g) => g.Roles); modelBuilder.Entity <ApplicationRoleGroup>() .HasKey((ApplicationRoleGroup gr) => new { RoleId = gr.RoleId, GroupId = gr.GroupId }).ToTable("ApplicationRoleGroups"); // And Here: EntityTypeConfiguration <Group> groupsConfig = modelBuilder.Entity <Group>().ToTable("Groups"); groupsConfig.Property((Group r) => r.Name).IsRequired(); //GiangTD3: EntityTypeConfiguration <MenuItem> MenuItemsConfig = modelBuilder.Entity <MenuItem>().ToTable("MenuItems"); // MenuItemsConfig.Property((MenuItem r) => r.Item_Action).IsRequired(); EntityTypeConfiguration <MenuItemRole> MenuItemRoleConfig = modelBuilder.Entity <MenuItemRole>().ToTable("MenuItemRoles"); //groupsConfig.Property((Group r) => r.Name).IsRequired(); EntityTypeConfiguration <MenuItemGroup> MenuItemGroupsConfig = modelBuilder.Entity <MenuItemGroup>().ToTable("MenuItemGroups"); // groupsConfig.Property((Group r) => r.Name).IsRequired(); EntityTypeConfiguration <MenuItemUser> MenuItemUsersConfig = modelBuilder.Entity <MenuItemUser>().ToTable("MenuItemUsers"); // groupsConfig.Property((Group r) => r.Name).IsRequired(); EntityTypeConfiguration <AccountLog> AccountLogsConfig = modelBuilder.Entity <AccountLog>().ToTable("AccountLogs"); // Leave this alone: EntityTypeConfiguration <IdentityUserLogin> entityTypeConfiguration = modelBuilder.Entity <IdentityUserLogin>().HasKey((IdentityUserLogin l) => new { UserId = l.UserId, LoginProvider = l.LoginProvider, ProviderKey = l.ProviderKey }).ToTable("AspNetUserLogins"); //entityTypeConfiguration.HasRequired<IdentityUser>((IdentityUserLogin u) => u.User); EntityTypeConfiguration <IdentityUserClaim> table1 = modelBuilder.Entity <IdentityUserClaim>().ToTable("AspNetUserClaims"); //table1.HasRequired<IdentityUser>((IdentityUserClaim u) => u.User); // Add this, so that IdentityRole can share a table with ApplicationRole: modelBuilder.Entity <IdentityRole>().ToTable("AspNetRoles"); // Change these from IdentityRole to ApplicationRole: EntityTypeConfiguration <ApplicationRole> entityTypeConfiguration1 = modelBuilder.Entity <ApplicationRole>().ToTable("AspNetRoles"); entityTypeConfiguration1.Property((ApplicationRole r) => r.Name).IsRequired(); }
public ProductBuilder(EntityTypeConfiguration <Product> builder) { builder.Property(b => b.Name).HasMaxLength(50).IsRequired(); builder.Property(b => b.Description).HasMaxLength(4000); }
protected override void OnModelCreating(DbModelBuilder modelBuilder) { EntityTypeConfiguration <Category> categoryMap = modelBuilder.Entity <Category>(); EntityTypeConfiguration <Bookmark> bookmarkMap = modelBuilder.Entity <Bookmark>(); }
public PostBuilder(EntityTypeConfiguration <Post> entity) //EntityTypeConfiguration entityn fluentapi tipi { entity.Property(p => p.Photo).IsRequired().HasMaxLength(200); entity.Property(p => p.Description).HasMaxLength(4000); entity.HasRequired(p => p.Planting).WithMany(m => m.Posts).HasForeignKey(p => p.PlantingId); }
public void CanBuildOperationBoundToCollectionCacheForIEdmModel() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType; customer.HasKey(c => c.ID); customer.Property(c => c.Name); customer.ComplexProperty(c => c.Address); EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType; movie.HasKey(m => m.ID); movie.HasKey(m => m.Name); EntityTypeConfiguration <Blockbuster> blockBuster = builder.EntityType <Blockbuster>().DerivesFrom <Movie>(); EntityTypeConfiguration movieConfiguration = builder.StructuralTypes.OfType <EntityTypeConfiguration>().Single(t => t.Name == "Movie"); // build actions that are bindable to the collection of entity customer.Collection.Action("CollectionCustomerActionInCache1"); customer.Collection.Action("CollectionCustomerActionInCache2"); movie.Collection.Action("CollectionMovieActionInCache3"); ActionConfiguration movieActionIncache4 = builder.Action("CollectionMovieActionInCache4"); CollectionTypeConfiguration collectionConfiguration = new CollectionTypeConfiguration(movieConfiguration, typeof(Movie)); movieActionIncache4.SetBindingParameter("bindingParameter", collectionConfiguration); blockBuster.Collection.Action("CollectionBlockbusterActionInCache5"); // build functions that are bindable to the collection of entity customer.Collection.Function("CollectionCustomerFunctionInCache1").Returns <int>(); customer.Collection.Function("CollectionCustomerFunctionInCache2").Returns <int>(); movie.Collection.Function("CollectionMovieFunctionInCache3").Returns <int>(); blockBuster.Collection.Function("CollectionBlockbusterFunctionInCache5").Returns <int>(); // build actions that are either: bindable to an entity, have no parameter, have only complex parameter customer.Action("CustomersActionNotInCache1"); customer.Function("CustomersFunctionNotInCache1").Returns <int>(); movie.Action("MoviesActionNotInCache2"); builder.Action("NoParametersNotInCache3"); ActionConfiguration addressParameterNotInCache4 = builder.Action("AddressParameterNotInCache4"); addressParameterNotInCache4.Parameter <Address>("address"); IEdmModel model = builder.GetEdmModel(); IEdmEntityType customerType = model.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "Customer"); IEdmEntityType movieType = model.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "Movie"); IEdmEntityType blockBusterType = model.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "Blockbuster"); // Act BindableOperationFinder annotation = new BindableOperationFinder(model); var movieOperations = annotation.FindOperationsBoundToCollection(movieType).ToArray(); var customerOperations = annotation.FindOperationsBoundToCollection(customerType).ToArray(); var blockBusterOperations = annotation.FindOperationsBoundToCollection(blockBusterType).ToArray(); // Assert Assert.Equal(3, movieOperations.Length); Assert.Single(movieOperations.Where(a => a.Name == "CollectionMovieActionInCache3")); Assert.Single(movieOperations.Where(a => a.Name == "CollectionMovieActionInCache4")); Assert.Single(movieOperations.Where(a => a.Name == "CollectionMovieFunctionInCache3")); Assert.Equal(4, customerOperations.Length); Assert.Single(customerOperations.Where(a => a.Name == "CollectionCustomerActionInCache1")); Assert.Single(customerOperations.Where(a => a.Name == "CollectionCustomerActionInCache2")); Assert.Single(customerOperations.Where(a => a.Name == "CollectionCustomerFunctionInCache1")); Assert.Single(customerOperations.Where(a => a.Name == "CollectionCustomerFunctionInCache2")); Assert.Equal(5, blockBusterOperations.Length); Assert.Single(blockBusterOperations.Where(a => a.Name == "CollectionBlockbusterActionInCache5")); Assert.Single(blockBusterOperations.Where(a => a.Name == "CollectionBlockbusterFunctionInCache5")); Assert.Single(blockBusterOperations.Where(a => a.Name == "CollectionMovieActionInCache3")); Assert.Single(blockBusterOperations.Where(a => a.Name == "CollectionMovieActionInCache4")); Assert.Single(blockBusterOperations.Where(a => a.Name == "CollectionMovieFunctionInCache3")); }
public override void OnModel(EntityTypeConfiguration <DelayToScheduler> entity) { entity.HasKey(r => r.Id) .Property(r => r.Id) .HasDatabaseGeneratedOption(DatabaseGeneratedOption.None); }
public void Can_generate_function_mappings_for_many_to_many_association_set_mapping() { var databaseMapping = new DbDatabaseMapping() .Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace)); var entityType1 = databaseMapping.Model.AddEntityType("E1"); entityType1.GetMetadataProperties().SetClrType(typeof(string)); databaseMapping.Model.AddEntitySet("E1Set", entityType1); var entityType2 = databaseMapping.Model.AddEntityType("E2"); entityType2.GetMetadataProperties().SetClrType(typeof(string)); databaseMapping.Model.AddEntitySet("E2Set", entityType2); var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); entityTypeConfiguration.MapToStoredProcedures(); entityType1.SetConfiguration(entityTypeConfiguration); entityType2.SetConfiguration(entityTypeConfiguration); var associationSet = databaseMapping.Model.AddAssociationSet( "M2MSet", databaseMapping.Model.AddAssociationType( "M2M", entityType1, RelationshipMultiplicity.Many, entityType2, RelationshipMultiplicity.Many)); var entitySet = new EntitySet("ES", "S", null, null, new EntityType("E", "N", DataSpace.CSpace)); var associationEndMember1 = new AssociationEndMember("Source", new EntityType("E", "N", DataSpace.CSpace)); associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember1)); var associationEndMember2 = new AssociationEndMember("Target", new EntityType("E", "N", DataSpace.CSpace)); associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember2)); var associationSetMapping = new AssociationSetMapping( associationSet, entitySet) { SourceEndMapping = new EndPropertyMapping() { AssociationEnd = associationEndMember1 }, TargetEndMapping = new EndPropertyMapping() { AssociationEnd = associationEndMember2 } }; associationSetMapping.SourceEndMapping .AddPropertyMapping(new ScalarPropertyMapping(new EdmProperty("PK"), new EdmProperty("FooId", TypeUsage.Create(new PrimitiveType() { DataSpace = DataSpace.SSpace })))); associationSetMapping.TargetEndMapping .AddPropertyMapping(new ScalarPropertyMapping(new EdmProperty("PK"), new EdmProperty("BarId", TypeUsage.Create(new PrimitiveType() { DataSpace = DataSpace.SSpace })))); var functionMappingGenerator = new ModificationFunctionMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest); functionMappingGenerator.Generate(associationSetMapping, databaseMapping); var modificationFunctionMapping = associationSetMapping.ModificationFunctionMapping; Assert.NotNull(modificationFunctionMapping); var functionMapping = modificationFunctionMapping.InsertFunctionMapping; Assert.NotNull(functionMapping); Assert.Equal(2, functionMapping.ParameterBindings.Count); Assert.Null(functionMapping.ResultBindings); var function = functionMapping.Function; Assert.NotNull(function); Assert.Equal("E1E2_Insert", function.Name); Assert.Equal(2, function.Parameters.Count); functionMapping = modificationFunctionMapping.DeleteFunctionMapping; Assert.NotNull(functionMapping); Assert.Equal(2, functionMapping.ParameterBindings.Count); Assert.Null(functionMapping.ResultBindings); function = modificationFunctionMapping.DeleteFunctionMapping.Function; Assert.NotNull(function); Assert.Equal("E1E2_Delete", function.Name); Assert.Equal(2, function.Parameters.Count); }
public BusinessAreaBuilder(EntityTypeConfiguration <BusinessArea> builder) { builder.Property(b => b.Name).HasMaxLength(100).IsRequired(); builder.Property(b => b.Description).HasMaxLength(4000); builder.HasOptional(a => a.MainArea).WithMany(b => b.ChildAreas).HasForeignKey(a => a.MainAreaId); }
public CategoryBuilder(EntityTypeConfiguration <Category> entity) { entity.HasKey(e => e.Id); entity.Property(e => e.Name).IsRequired().HasMaxLength(100); }
protected virtual void Configure(EntityTypeConfiguration <TSaga> cfg, DbModelBuilder modelBuilder) { }
protected override void OnModelCreating(DbModelBuilder modelBuilder) { modelBuilder.Entity <Consultation>() .HasMany(c => c.Symptomses).WithMany(i => i.Consultations) .Map(t => t.MapLeftKey("ConsultId") .MapRightKey("Symptomsid") .ToTable("ConsultationSymptoms")); modelBuilder.Entity <Consultation>() .HasMany(c => c.Illness).WithMany(i => i.Consultations) .Map(t => t.MapLeftKey("ConsultId") .MapRightKey("IllnessId") .ToTable("ConsultationIllness")); modelBuilder.Entity <Consultation>() .HasMany(c => c.CustLis).WithMany(i => i.consultation) .Map(t => t.MapLeftKey("ConsultId") .MapRightKey("custId") .ToTable("ConsultationMedicine")); modelBuilder.Entity <Consultation>() .HasMany(c => c.TestTypes).WithMany(i => i.Consultations) .Map(t => t.MapLeftKey("ConsultId") .MapRightKey("TestTypeID") .ToTable("ConsultTests")); modelBuilder.Entity <Consultation>() .HasMany(c => c.Drugs).WithMany(i => i.Consultations) .Map(t => t.MapLeftKey("ConsultId") .MapRightKey("DrugId") .ToTable("ConsultDrugs")); modelBuilder.Conventions.Remove <OneToManyCascadeDeleteConvention>(); modelBuilder.Entity <IdentityUser>().ToTable("AspNetUsers"); EntityTypeConfiguration <ApplicationUser> table = modelBuilder.Entity <ApplicationUser>().ToTable("AspNetUsers"); table.Property((ApplicationUser u) => u.UserName).IsRequired(); //EntityTypeConfiguration<Patient> patient_table = // modelBuilder.Entity<Patient>().ToTable("AspNetUsers"); //patient_table.Property((Patient u) => u.UserName).IsRequired(); modelBuilder.Entity <ApplicationUser>().HasMany <IdentityUserRole>((ApplicationUser u) => u.Roles); //modelBuilder.Entity<Patient>().HasMany<IdentityUserRole>((Patient u) => u.Roles); modelBuilder.Entity <IdentityUserRole>().HasKey((IdentityUserRole r) => new { UserId = r.UserId, RoleId = r.RoleId }).ToTable("AspNetUserRoles"); EntityTypeConfiguration <IdentityUserLogin> entityTypeConfiguration = modelBuilder.Entity <IdentityUserLogin>().HasKey((IdentityUserLogin l) => new { UserId = l.UserId, LoginProvider = l.LoginProvider, ProviderKey = l.ProviderKey }).ToTable("AspNetUserLogins"); modelBuilder.Entity <IdentityRole>().ToTable("AspNetRoles"); EntityTypeConfiguration <ApplicationRole> entityTypeConfiguration1 = modelBuilder.Entity <ApplicationRole>().ToTable("AspNetRoles"); entityTypeConfiguration1.Property((ApplicationRole r) => r.Name).IsRequired(); }
public static void SetEntityConfiguration(DbModelBuilder modelBuilder) { EntityTypeConfiguration <TemplateDto> profileConfig = modelBuilder.Entity <TemplateDto>(); // Entity to Table mapping profileConfig.ToTable("COMP_PROFILE_TEMPLATE"); // Entity property to column name mapping #region - Column Mappings - profileConfig .Property(t => t.TemplateId) .HasColumnName("TEMPLATE_ID") .HasColumnOrder(1) .HasColumnType("NUMBER"); profileConfig .Property(t => t.TemplateName) .HasColumnName("TEMPLATE_NAME") .IsRequired() .HasColumnOrder(2) .HasColumnType("VARCHAR2"); profileConfig .Property(t => t.TemplateDesc) .HasColumnName("TEMPLATE_DESC") .HasMaxLength(10) .IsRequired() .HasColumnType("VARCHAR2"); profileConfig .Property(t => t.CompanyCode) .HasColumnName("CO_CD") .IsRequired() .HasMaxLength(50) .IsRequired() .HasColumnType("VARCHAR2"); profileConfig .Property(t => t.RuleSetVersion) .HasColumnName("TEMPLATE_FILE_NAME") .HasMaxLength(250) .HasColumnType("VARCHAR2"); profileConfig .Property(t => t.CreatedBy) .HasColumnName("CREATED_BY") .IsRequired() .HasMaxLength(30) .IsRequired() .HasColumnType("VARCHAR2"); profileConfig .Property(t => t.CreatedDt) .HasColumnName("CREATED_DT") .HasColumnType("DATE"); profileConfig .Property(t => t.UpdatedBy) .HasColumnName("UPDATED_BY") .IsRequired() .HasColumnType("VARCHAR2"); profileConfig .Property(t => t.UpdatedDt) .HasColumnName("UPDATED_DT") .IsRequired() .HasColumnType("DATE"); profileConfig .Property(t => t.ProfileTemplate) .HasColumnName("PROFILE_TEMPLATE") .HasMaxLength(100) .HasColumnType("CLOB"); profileConfig .Property(t => t.Status) .HasColumnName("STATUS") .HasMaxLength(15) .HasColumnType("VARCHAR2"); profileConfig .Property(t => t.TemplateGuid) .HasColumnName("TEMPLATE_GUID") .IsRequired() .HasColumnType("RAW"); profileConfig .Property(t => t.TemplateVersion) .HasColumnName("TEMPLATE_VERSION") .HasColumnType("NUMBER"); #endregion // Set Primary key profileConfig.HasKey(tz => new { tz.TemplateId }); }
public CompanyTypeBuilder(EntityTypeConfiguration <CompanyType> builder) { builder.Property(b => b.Name).HasMaxLength(50).IsRequired(); }
public TreeTypeBuilder(EntityTypeConfiguration <TreeType> entity) { entity.Property(p => p.Name).IsRequired().HasMaxLength(200); entity.Property(p => p.Photo).IsRequired().HasMaxLength(200); entity.HasRequired(p => p.Region).WithMany(m => m.TreeTypes).HasForeignKey(p => p.RegionId).WillCascadeOnDelete(false); }
public UserGroupBuilder(EntityTypeConfiguration <UserGroup> builder) { builder.Property(b => b.Name).HasMaxLength(100).IsRequired(); builder.Property(b => b.Description).HasMaxLength(4000); builder.HasOptional(a => a.Language).WithMany(b => b.UserGroups).HasForeignKey(a => a.LanguageId); }
public static void AddConfiguration <TEntity>( this ModelBuilder modelBuilder, EntityTypeConfiguration <TEntity> configuration) where TEntity : class { configuration.Map(modelBuilder.Entity <TEntity>()); }
public PurchasingDepartmentBuilder(EntityTypeConfiguration <PurchasingDepartment> builder) { builder.Property(b => b.Name).HasMaxLength(100).IsRequired(); builder.HasRequired(a => a.Company).WithMany(b => b.PurchasingDepartments).HasForeignKey(a => a.CompanyId); }
public LicenseBuilder(EntityTypeConfiguration <LicenseEntity> modelBuilder) { modelBuilder.ToTable(TableName); modelBuilder.HasIndex(b => b.Id); }
public CityBuilder(EntityTypeConfiguration <City> builder) { builder.Property(b => b.Name).HasMaxLength(50).IsRequired(); builder.HasRequired(a => a.Country).WithMany(b => b.Cities).HasForeignKey(a => a.CountryId); }
public DocumentBuilder(EntityTypeConfiguration <Document> builder) { builder.Property(b => b.Name).HasMaxLength(100).IsRequired(); builder.Property(b => b.File).HasMaxLength(200).IsRequired(); builder.Property(b => b.Description).HasMaxLength(4000); }