protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {

            #region Contact
            modelBuilder.Entity<ContactDataEntity>().HasKey(x => x.Id)
                .Property(x => x.Id);
            modelBuilder.Entity<ContactDataEntity>().ToTable("Contact");

            #endregion

            #region Organization
            modelBuilder.Entity<OrganizationDataEntity>().HasKey(x => x.Id)
                .Property(x => x.Id);
            modelBuilder.Entity<OrganizationDataEntity>().ToTable("Organization");
            #endregion

            #region Employee
            modelBuilder.Entity<EmployeeDataEntity>().HasKey(x => x.Id)
                .Property(x => x.Id);
            modelBuilder.Entity<EmployeeDataEntity>().ToTable("Employee");

            #endregion

            #region Vendor
            modelBuilder.Entity<VendorDataEntity>().HasKey(x => x.Id)
                .Property(x => x.Id);
            modelBuilder.Entity<VendorDataEntity>().ToTable("Vendor");

            #endregion
      
            base.OnModelCreating(modelBuilder);
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Configurations
                .Add(new EntityTypeConfigBase<Account>());

            base.OnModelCreating(modelBuilder);
        }
Exemple #3
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Entity<Test>().Property(Test.NameExpression);
     modelBuilder.Entity<Test>().Property(Test.IdExpression);
     modelBuilder.Entity<Test>().Property(Test.TypeTestExpression);
     modelBuilder.Entity<Test2>().Property(Test2.TypeTest2Expression);
 }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {

            modelBuilder.Conventions.Remove<IncludeMetadataConvention>();
            //#if CONFIGURATION

            //modelBuilder.Entity<Blog>().ToTable("InternalBlogs", "dbo");

            //modelBuilder.Entity<Blog>().HasKey(b => new { b.Id, b.Title });
            //modelBuilder.Entity<Blog>().Property(p => p.Title).HasColumnName("BlogTitle").IsMaxLength();
            //modelBuilder.Entity<Blog>().Property(p => p.DateCreated)
            //    .HasColumnName("CreatedDate")
            //    .HasColumnOrder(1)
            //    .HasColumnType("date");

            //modelBuilder.Entity<Blog>().Map(
            //    mca =>
            //    {
            //        mca.Properties(b => new { b.Id, b.Title, b.BloggerName });
            //        mca.ToTable("InternalBlogs");
            //    }).Map(
            //            mca =>
            //            {
            //                mca.Properties(b => new { b.DateCreated });
            //                mca.ToTable("BlogDetails");
            //            });


            //modelBuilder.ComplexType<BlogDetails>();

            // If Post does not have a BlogId property, this configuration is required
                // so that all posts are bound to one Blog
            modelBuilder.Entity<Post>().HasRequired(p => p.Blog);
            modelBuilder.Entity<Person>()
                    .Map<PowerUser>(m => m.Requires("Type").HasValue("PU"))
                    .Map <RegularUser>(m => m.Requires("Type").HasValue("RU"));

            // To support the unconventional foreign key FKBlogId in Post this configuration is required
            modelBuilder.Entity<Post>()
                .HasOptional(p => p.Blog)
                .WithMany(b => b.Posts)
                //.HasForeignKey(p => p.FKBlogId)
                ;

            modelBuilder.Entity<Post>()
                .HasMany(p => p.Tags)
                .WithMany(t => t.Posts)
                .Map(mc =>
                {
                    mc.ToTable("PostJoinTag");
                    mc.MapLeftKey("PostId");
                    mc.MapRightKey("TagId");
                });


            // Configuration with entity configuration
            //modelBuilder.Configurations.Add(new BlogConfiguration());
            //#endif

        }
Exemple #5
0
       // public IDbSet<TalonAmount> TalonAmounts{ get; set; }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

         //   modelBuilder.Entity<Employee>().H
        }
Exemple #6
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<TB_PRODUCT>()
                .Property(e => e.ID)
                .HasPrecision(20, 0);

            modelBuilder.Entity<TB_PRODUCT>()
                .Property(e => e.S_ID)
                .HasPrecision(20, 0);

            modelBuilder.Entity<TB_PRODUCT>()
                .Property(e => e.TYPE)
                .IsUnicode(false);

            modelBuilder.Entity<TB_PRODUCT>()
                .Property(e => e.NAME)
                .IsUnicode(false);

            modelBuilder.Entity<TB_PRODUCT>()
                .Property(e => e.PRICE)
                .HasPrecision(15, 2);

            modelBuilder.Entity<TB_PRODUCT>()
                .Property(e => e.DISCOUNT_RATE)
                .HasPrecision(2, 2);

            modelBuilder.Entity<TB_PRODUCT>()
                .Property(e => e.DESCRIPTION)
                .IsUnicode(false);

            modelBuilder.Entity<TB_PRODUCT>()
                .Property(e => e.NUM)
                .HasPrecision(20, 0);
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder
                .Entity<Book>()
                .ToTable("Book", "bs")
                .HasKey(b => b.Id);

            modelBuilder
                .Entity<Book>()
                .HasRequired(b => b.Author);

            modelBuilder
                .Entity<Book>()
                .HasMany(b => b.Genres)
                .WithMany(g => g.Books)
                .Map(bg =>
                {
                    bg.MapLeftKey("BookId");
                    bg.MapRightKey("GenreId");
                    bg.ToTable("BooksGenres", "bs");
                });

            modelBuilder
                .Entity<Author>()
                .ToTable("Author", "bs")
                .HasKey(a => a.Id);

            modelBuilder
                .Entity<Genre>()
                .ToTable("Genre", "bs")
                .HasKey(g => g.Id);
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            modelBuilder.Entity<Consent>().ToTable(EfConstants.TableNames.Consent, Schema);
            modelBuilder.Entity<Token>().ToTable(EfConstants.TableNames.Token, Schema);
        }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Configurations.Add(new IdentificationTypeConfiguration());
     modelBuilder.Configurations.Add(new PersonConfiguration());
     modelBuilder.Configurations.Add(new GatePassConfiguration());
     modelBuilder.Configurations.Add(new RequestStatusConfiguration());
 }
Exemple #10
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            if (modelBuilder == null) throw new ArgumentNullException(nameof(modelBuilder));

            modelBuilder.Configurations.Add(new CommandEntityConfiguration(SchemaName));
            modelBuilder.Configurations.Add(new EventEntityConfiguration(SchemaName));
        }
Exemple #11
0
        public void Update_exceptions_should_be_wrapped_when_generating_sproc_bodies()
        {
            var modelBuilder = new DbModelBuilder();

            var model1 = modelBuilder.Build(ProviderInfo);

            var context = new WorldContext_Invalid();

            var commandTreeGenerator
                = new ModificationCommandTreeGenerator(
                    context
                        .InternalContext
                        .CodeFirstModel
                        .CachedModelBuilder
                        .BuildDynamicUpdateModel(ProviderRegistry.Sql2008_ProviderInfo));

            Assert.Throws<InvalidOperationException>(
                () => new EdmModelDiffer()
                    .Diff(
                        model1.GetModel(),
                        context.GetModel(),
                        new Lazy<ModificationCommandTreeGenerator>(() => commandTreeGenerator),
                        new SqlServerMigrationSqlGenerator())
                    .OfType<CreateProcedureOperation>()
                    .ToList())
                .ValidateMessage("ErrorGeneratingCommandTree", "Thing_Insert", "Thing");
        }
Exemple #12
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            modelBuilder.Entity<HistoryRow>().Property(m => m.MigrationId).HasMaxLength(100).IsRequired();
            modelBuilder.Entity<HistoryRow>().Property(m => m.ContextKey).HasMaxLength(200).IsRequired();
        }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Entity<Feature>()
         .HasMany(e => e.Feedback)
         .WithRequired(e => e.Feature)
         .WillCascadeOnDelete(false);
 }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Conventions.Remove<System.Data.Entity.ModelConfiguration.Conventions.PluralizingTableNameConvention>();
     modelBuilder.Entity<Instructor>().HasOptional(i => i.OfficeAssignment).WithRequired(o => o.Instructor);
     modelBuilder.Entity<Course>().HasMany(c => c.Instructors).WithMany(i => i.Courses).Map(t => t.MapLeftKey("CourseID").MapRightKey("InstructorID").ToTable("CourseInstructor"));
     modelBuilder.Entity<Department>().HasOptional(d => d.Administrator);
 }
Exemple #15
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     base.OnModelCreating(modelBuilder);
     modelBuilder.Entity<Customer>().ToTable("tblCustomers");//table mapping
     modelBuilder.Entity<Order>().ToTable("tblOrders");
     modelBuilder.Entity<Customer>().Property(x => x.CustomerCode).HasColumnName("CustomerCode");//column mapping
 }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<User>()
                .HasMany(u => u.Friends).WithMany()
                .Map(m =>
                {
                    m.MapLeftKey("UserId");
                    m.MapRightKey("FriendId");
                    m.ToTable("UserFriends");
                });

            modelBuilder.Entity<User>()
                .HasMany(u => u.ProductsBought)
                .WithOptional(p => p.Buyer)
                .Map(m =>
                {
                    m.MapKey("BuyerId");
                });

            modelBuilder.Entity<User>()
                .HasMany(u => u.ProductsSold)
                .WithRequired(p => p.Seller)
                .Map(m =>
                {
                    m.MapKey("SellerId");
                });

            base.OnModelCreating(modelBuilder);
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Movies>()
                .HasMany(e => e.Favorites)
                .WithRequired(e => e.Movies)
                .HasForeignKey(e => e.MovieId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Movies>()
                .HasMany(e => e.UserMovieMarks)
                .WithRequired(e => e.Movies)
                .HasForeignKey(e => e.IdMovie)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Roles>()
                .HasMany(e => e.Users)
                .WithRequired(e => e.Roles)
                .HasForeignKey(e => e.Role)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Users>()
                .HasMany(e => e.Favorites)
                .WithRequired(e => e.Users)
                .HasForeignKey(e => e.UserId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Users>()
                .HasMany(e => e.UserMovieMarks)
                .WithRequired(e => e.Users)
                .HasForeignKey(e => e.IdUser)
                .WillCascadeOnDelete(false);
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            // Conventions
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
            modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();
            modelBuilder.Conventions.Remove<ManyToManyCascadeDeleteConvention>();

            // General Custom Context Properties
            modelBuilder.Properties()
                .Where(p => p.Name == p.ReflectedType.Name + "Id")
                .Configure(p => p.IsKey());

            modelBuilder.Properties<string>()
                .Configure(p => p.HasColumnType("varchar"));

            modelBuilder.Properties<string>()
                .Configure(p => p.HasMaxLength(100));

            modelBuilder.Configurations.Add(new TipoCursoConfiguration());
            modelBuilder.Configurations.Add(new CursoConfiguration());
            modelBuilder.Configurations.Add(new UsuarioConfiguration());
            modelBuilder.Configurations.Add(new AlunoConfiguration());
            modelBuilder.Configurations.Add(new AlunoHistoricoConfiguration());

            base.OnModelCreating(modelBuilder);
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Configurations.Add(new PeopleMap());
            modelBuilder.Configurations.Add(new ColourMap());

            base.OnModelCreating(modelBuilder);
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Post>()
                .HasMany(e => e.Comments)
                .WithRequired(e => e.Post)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Post>()
                .HasMany(e => e.Tags)
                .WithMany(e => e.Posts)
                .Map(m => m.ToTable("PostsTags").MapLeftKey("PostId").MapRightKey("TagId"));

            modelBuilder.Entity<User>()
                .Property(e => e.UserName)
                .IsUnicode(false);

            modelBuilder.Entity<User>()
                .HasMany(e => e.Comments)
                .WithOptional(e => e.User)
                .HasForeignKey(e => e.AuthorId);

            modelBuilder.Entity<User>()
                .HasMany(e => e.Posts)
                .WithOptional(e => e.User)
                .HasForeignKey(e => e.AuthorId);
        }
Exemple #21
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     //modelBuilder.Entity<Phone>().ToTable("Mobiles");
     modelBuilder.Entity<Phone>().HasKey(p => p.Ident);
     //modelBuilder.Entity<Phone>().Ignore(p => p.Discount);
     //base.OnModelCreating(modelBuilder);
 }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Configurations.Add(new Mapping.SexoMapping());
     modelBuilder.Configurations.Add(new Mapping.EstadoCivilMapping());
     modelBuilder.Configurations.Add(new Mapping.ContatoMapping());
     base.OnModelCreating(modelBuilder);
 }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Entity<NumberForLinq>().HasKey(e => e.Id);
     modelBuilder.Entity<ProductForLinq>().HasKey(e => e.Id);
     modelBuilder.Entity<CustomerForLinq>().HasKey(e => e.Id);
     modelBuilder.Entity<OrderForLinq>().HasKey(e => e.Id);
 }
Exemple #24
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            //

            modelBuilder.HasDefaultSchema("TDP");
            modelBuilder.Entity<Persona>().ToTable("Persona");
            modelBuilder.Entity<Telefono>().ToTable("Telefono");

            modelBuilder.Entity<Persona>()
                        .HasMany<Telefono>(p => p.Telefonos);
                       /* .WithRequired()
                        .Map(a => a.MapKey("Persona"))
                        .WillCascadeOnDelete(true);*/

            modelBuilder.Entity<Persona>().HasKey<int>(p => p.PersonaId);

            modelBuilder.Entity<Telefono>().HasKey<int>(t => t.TelefonoId);

            modelBuilder.Entity<Persona>()
                        .Property(p => p.PersonaId)
                        .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);

            modelBuilder.Entity<Telefono>()
                        .Property(t => t.TelefonoId)
                        .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);

            base.OnModelCreating(modelBuilder);
        }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
   modelBuilder.Configurations.Add(new BettingPAndLMap());
   modelBuilder.Configurations.Add(new BookmakerMap());
   modelBuilder.Configurations.Add(new TournamentCouponURLMap());
   modelBuilder.Configurations.Add(new CompetitionCouponURLMap());
   modelBuilder.Configurations.Add(new CompetitionMap());
   modelBuilder.Configurations.Add(new TournamentMap());
   modelBuilder.Configurations.Add(new TournamentEventMap());
   modelBuilder.Configurations.Add(new ExternalSourceMap());
   modelBuilder.Configurations.Add(new FundMap());
   modelBuilder.Configurations.Add(new MatchCouponURLMap());
   modelBuilder.Configurations.Add(new MatchMap());
   modelBuilder.Configurations.Add(new MatchOutcomeOddMap());
   modelBuilder.Configurations.Add(new MatchOutcomeProbabilitiesInMatchMap());
   modelBuilder.Configurations.Add(new MatchOutcomeMap());
   modelBuilder.Configurations.Add(new ObservedOutcomeMap());
   modelBuilder.Configurations.Add(new ScoreOutcomeProbabilitiesInMatchMap());
   modelBuilder.Configurations.Add(new ScoreOutcomeMap());
   modelBuilder.Configurations.Add(new SportMap());
   modelBuilder.Configurations.Add(new SurfaceMap());
   modelBuilder.Configurations.Add(new TeamPlayerExternalSourceAliasMap());
   modelBuilder.Configurations.Add(new TeamsPlayerMap());
   modelBuilder.Configurations.Add(new TournamentExternalSourceAliasMap());
   modelBuilder.Configurations.Add(new BookmakerExternalSourceAliasMap());
   modelBuilder.Configurations.Add(new KeyValuePairMap());
   modelBuilder.Configurations.Add(new TennisPredictionStatMap());
   modelBuilder.Configurations.Add(new MissingBookmakerExternalSourceAliasMap());
   modelBuilder.Configurations.Add(new MissingTeamPlayerExternalSourceAliasMap());
   modelBuilder.Configurations.Add(new MissingTournamentCouponURLMap());
   modelBuilder.Configurations.Add(new OutcomeCommentMap());
 }
        /// <summary>
        /// This method is called when the model for a derived context has been initialized, but
        /// before the model has been locked down and used to initialize the context.  The default
        /// implementation of this method does nothing, but it can be overridden in a derived class
        /// such that the model can be further configured before it is locked down.
        /// </summary>
        /// <param name="modelBuilder">The builder that defines the model for the context being created.</param>
        /// <remarks>Typically, this method is called only once when the first instance of a derived context
        /// is created.  The model for that context is then cached and is for all further instances of
        /// the context in the app domain.  This caching can be disabled by setting the ModelCaching
        /// property on the given ModelBuidler, but note that this can seriously degrade performance.
        /// More control over caching is provided through use of the DbModelBuilder and DbContextFactory
        /// classes directly.</remarks>
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            //modelBuilder.Configurations.Add(new RaceMapping());
            modelBuilder.Configurations.Add(new CreatureMapping());

            base.OnModelCreating(modelBuilder);
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            modelBuilder.Conventions.Add(new DateTimePrecisionAttributeConvention());
            modelBuilder.Conventions.Add(new DecimalPrecisionAttributeConvention());
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

            modelBuilder.Configurations.Add(new JobInfoMap());
            base.OnModelCreating(modelBuilder);
        }
Exemple #29
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<WorkNC_Factory>()
                .Property(e => e.ImageFile)
                .IsUnicode(false);

            modelBuilder.Entity<WorkNC_WorkZone>()
                .Property(e => e.MachiningTimeTotal)
                .IsFixedLength();

            modelBuilder.Entity<WorkNC_WorkZone>()
                .Property(e => e.ImageFile)
                .IsUnicode(false);

            modelBuilder.Entity<WorkNC_WorkZoneDetail>()
                .Property(e => e.MachineTime)
                .IsFixedLength();

            modelBuilder.Entity<WorkNC_WorkZoneDetail>()
                .Property(e => e.ImageFile)
                .IsUnicode(false);

            modelBuilder.Entity<WorkNC_WorkZoneDetailProblem>()
                .Property(e => e.ImageFile)
                .IsUnicode(false);
        }
Exemple #30
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Dish>()
                .Property(e => e.DishName)
                .IsUnicode(false);

            modelBuilder.Entity<Dish>()
                .HasMany(e => e.DishesProducts)
                .WithRequired(e => e.Dish)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Dish>()
                .HasMany(e => e.PersonEatStories)
                .WithRequired(e => e.Dish)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Person>()
                .Property(e => e.PersonName)
                .IsUnicode(false);

            modelBuilder.Entity<Person>()
                .HasMany(e => e.PersonEatStories)
                .WithRequired(e => e.Person)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Product>()
                .Property(e => e.ProductName)
                .IsUnicode(false);

            modelBuilder.Entity<Product>()
                .HasMany(e => e.DishesProducts)
                .WithRequired(e => e.Product)
                .WillCascadeOnDelete(false);
        }
Exemple #31
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     base.OnModelCreating(modelBuilder);
     modelBuilder.Entity <User>().ToTable("AspNetUsers");
 }
Exemple #32
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     throw new UnintentionalCodeFirstException();
 }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            modelBuilder.Entity<User>()
            .HasMany(u => u.Businesses);

            modelBuilder.Entity<Bulletin>()
            .HasOptional(b => b.Picture)
            .WithRequired(p => p.Bulletin)
            .WillCascadeOnDelete(true);

            modelBuilder.Entity<JobExperience>()
            .HasMany<Models.Environment>(s => s.Environments)
            .WithMany(e => e.JobExperiences)
            .Map(cs =>
            {
                cs.MapLeftKey("JobExperienceId");
                cs.MapRightKey("EnvironmentId");
                cs.ToTable("JobexpEnv");
            });

            modelBuilder.Entity<JobExperience>()
            .HasMany<Models.Subject>(s => s.Subjects)
            .WithMany(e => e.JobExperiences)
            .Map(cs =>
            {
                cs.MapLeftKey("JobExperienceId");
                cs.MapRightKey("SubjectId");
                cs.ToTable("JobexpSubj");
            });

            modelBuilder.Entity<JobExperience>()
            .HasMany<Models.Title>(s => s.Titles)
            .WithMany(e => e.JobExperiences)
            .Map(cs =>
            {
                cs.MapLeftKey("JobExperienceId");
                cs.MapRightKey("TitleId");
                cs.ToTable("JobexpTit");
            });

            //Creates relation between user and jobexperiences. 
            //User is required for jobExperience to exist.
            //If user is deleted, all JobExperiences will be deleted.
            modelBuilder.Entity<User>()
            .HasMany(u => u.JobExperiences)
            .WithRequired(j => j.ApplicationUser)
            .WillCascadeOnDelete(true);


            modelBuilder.Entity<User>()
            .HasMany(u => u.Educations)
            .WithRequired(e => e.ApplicationUser)
            .WillCascadeOnDelete(true);

            modelBuilder.Entity<User>()
            .HasMany(u => u.Clauses)
            .WithRequired(c => c.ApplicationUser)
            .WillCascadeOnDelete(true);

            modelBuilder.Entity<UserLanguages>()
                .HasKey(ul => new { ul.LanguageId, ul.UserId });

            modelBuilder.Entity<UserLanguages>()
                .HasRequired(ul => ul.User)
                .WithMany(ul => ul.Languages)
                .HasForeignKey(pl => pl.UserId);

            modelBuilder.Entity<UserLanguages>()
                .HasRequired(ul => ul.Language)
                .WithMany(ul => ul.Users)
                .HasForeignKey(ul => ul.LanguageId);

            /*modelBuilder.Entity<User>()
            .HasMany<Models.Language>(s => s.Languages)
            .WithMany(e => e.Users)
            .Map(cs =>
            {
                cs.MapLeftKey("Id");
                cs.MapRightKey("LanguageId");
                cs.ToTable("UserLanguage");
            });*/

            modelBuilder.Entity<User>()
            .HasMany(u => u.Certificates)
            .WithRequired(c => c.ApplicationUser)
            .WillCascadeOnDelete(true);

        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            var ensureDLLIsCopied = System.Data.Entity.SqlServer.SqlProviderServices.Instance;

        }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     // PostgreSQL uses the public schema by default - not dbo.
     modelBuilder.HasDefaultSchema("public");
     base.OnModelCreating(modelBuilder);
 }
Exemple #36
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Configurations.Add(new CourseConfiguration());
 }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     base.OnModelCreating(modelBuilder);
     modelBuilder.Entity <publicMomentPhoto>().ToTable("publicMomentPhoto");
 }
Exemple #38
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Entity <Employee>().ToTable("TblEmployee");
     base.OnModelCreating(modelBuilder);
 }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            modelBuilder.Entity <User>().HasIndex(u => u.SteamId).IsUnique();            // TODO: Needed?
        }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     Database.SetInitializer <TweetDbContext>(null);
     base.OnModelCreating(modelBuilder);
 }
Exemple #41
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity <Autores>()
            .Property(e => e.Nome)
            .IsUnicode(false);

            modelBuilder.Entity <Autores>()
            .Property(e => e.Descricao)
            .IsUnicode(false);

            modelBuilder.Entity <Autores>()
            .HasMany(e => e.Livros)
            .WithMany(e => e.Autores)
            .Map(m => m.ToTable("LivroAutor").MapLeftKey("Autor").MapRightKey("Livro"));

            modelBuilder.Entity <Editoras>()
            .Property(e => e.Nome)
            .IsUnicode(false);

            modelBuilder.Entity <Editoras>()
            .Property(e => e.Descricao)
            .IsUnicode(false);



            modelBuilder.Entity <Generos>()
            .Property(e => e.Tipo)
            .IsUnicode(false);

            modelBuilder.Entity <Generos>()
            .Property(e => e.Descricao)
            .IsUnicode(false);



            modelBuilder.Entity <Livros>()
            .Property(e => e.Titulo)
            .IsUnicode(false);

            modelBuilder.Entity <Livros>()
            .Property(e => e.Isbn)
            .IsUnicode(false);

            modelBuilder.Entity <Livros>()
            .Property(e => e.Observacoes)
            .IsUnicode(false);

            modelBuilder.Entity <Livros>()
            .HasMany(e => e.Locacao)
            .WithRequired(e => e.Livros)
            .HasForeignKey(e => e.Livro)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <Usuarios>()
            .Property(e => e.Nome)
            .IsUnicode(false);

            modelBuilder.Entity <Usuarios>()
            .Property(e => e.Login)
            .IsUnicode(false);

            modelBuilder.Entity <Usuarios>()
            .Property(e => e.Senha)
            .IsUnicode(false);

            modelBuilder.Entity <Usuarios>()
            .Property(e => e.Email)
            .IsUnicode(false);


            modelBuilder.Entity <Usuarios>()
            .HasMany(e => e.Locacao)
            .WithRequired(e => e.Usuarios)
            .HasForeignKey(e => e.UsuAlt)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <Usuarios>()
            .HasMany(e => e.Locacao1)
            .WithRequired(e => e.Usuarios1)
            .HasForeignKey(e => e.Usuario)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <Usuarios>()
            .HasMany(e => e.Locacao2)
            .WithRequired(e => e.Usuarios2)
            .HasForeignKey(e => e.UsuInc)
            .WillCascadeOnDelete(false);
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity <Empresas>()
            .Property(e => e.Codigo)
            .IsUnicode(false);

            modelBuilder.Entity <Empresas>()
            .Property(e => e.RazaoSocial)
            .IsUnicode(false);

            modelBuilder.Entity <Empresas>()
            .Property(e => e.Logradouro)
            .IsUnicode(false);

            modelBuilder.Entity <Empresas>()
            .Property(e => e.Numero)
            .IsUnicode(false);

            modelBuilder.Entity <Empresas>()
            .Property(e => e.Complemento)
            .IsUnicode(false);

            modelBuilder.Entity <Empresas>()
            .Property(e => e.Bairro)
            .IsUnicode(false);

            modelBuilder.Entity <Empresas>()
            .Property(e => e.Cep)
            .IsUnicode(false);

            modelBuilder.Entity <Empresas>()
            .Property(e => e.Tipo)
            .IsUnicode(false);

            modelBuilder.Entity <Empresas>()
            .Property(e => e.CnpjCpf)
            .IsUnicode(false);

            modelBuilder.Entity <Estados>()
            .Property(e => e.CodigoIbge)
            .IsUnicode(false);

            modelBuilder.Entity <Estados>()
            .Property(e => e.Sigla)
            .IsUnicode(false);

            modelBuilder.Entity <Estados>()
            .Property(e => e.Descricao)
            .IsUnicode(false);

            modelBuilder.Entity <Estados>()
            .HasMany(e => e.Empresas)
            .WithRequired(e => e.Estados)
            .HasForeignKey(e => e.IdEstado)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <Estados>()
            .HasMany(e => e.Municipios)
            .WithRequired(e => e.Estados)
            .HasForeignKey(e => e.IdEstado)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <Municipios>()
            .Property(e => e.CodigoIbge)
            .IsUnicode(false);

            modelBuilder.Entity <Municipios>()
            .Property(e => e.Descricao)
            .IsUnicode(false);

            modelBuilder.Entity <Municipios>()
            .HasMany(e => e.Empresas)
            .WithRequired(e => e.Municipios)
            .HasForeignKey(e => e.IdMunicipio)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <Paises>()
            .Property(e => e.CodigoIbge)
            .IsUnicode(false);

            modelBuilder.Entity <Paises>()
            .Property(e => e.CodigoSiscomex)
            .IsUnicode(false);

            modelBuilder.Entity <Paises>()
            .Property(e => e.Descricao)
            .IsUnicode(false);

            modelBuilder.Entity <Paises>()
            .HasMany(e => e.Empresas)
            .WithRequired(e => e.Paises)
            .HasForeignKey(e => e.IdPais)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <TipoLogradouros>()
            .Property(e => e.Descricao)
            .IsUnicode(false);

            modelBuilder.Entity <TipoLogradouros>()
            .HasMany(e => e.Empresas)
            .WithOptional(e => e.TipoLogradouros)
            .HasForeignKey(e => e.IdTipoLogradouro);
        }
 //添加Mapper类,将数据库映射到类
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Configurations.Add(new InstallMapper());//添加映射
 }//映射
Exemple #44
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Entity <Favorite>()
     .Property(e => e.Name)
     .IsUnicode(false);
 }
Exemple #45
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Entity <Customer>()
     .Property(e => e.AccountNumber)
     .IsUnicode(false);
 }
Exemple #46
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     base.OnModelCreating(modelBuilder);
 }
Exemple #47
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Conventions.Remove <PluralizingTableNameConvention>();
     modelBuilder.Entity <Course>().Property(c => c.Credits).HasPrecision(14, 2);
 }
Exemple #48
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     //base.OnModelCreating(modelBuilder);
     // 这句是不要将EF生成的sql表名不要被复数 就是表名后面不要多加个S
     modelBuilder.Conventions.Remove <PluralizingTableNameConvention>();
 }
Exemple #49
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity <Account>()
            .Property(e => e.AccountType)
            .IsUnicode(false);

            modelBuilder.Entity <Account>()
            .Property(e => e.AccountPassword)
            .IsUnicode(false);

            modelBuilder.Entity <Account>()
            .HasMany(e => e.Plans)
            .WithMany(e => e.Accounts)
            .Map(m => m.ToTable("PlanHistory").MapLeftKey("AccountID").MapRightKey("PlanID"));

            modelBuilder.Entity <Activity>()
            .Property(e => e.ActivityName)
            .IsUnicode(false);

            modelBuilder.Entity <Activity>()
            .Property(e => e.ActivityType)
            .IsUnicode(false);

            modelBuilder.Entity <Activity>()
            .Property(e => e.ActivityPlaceID);

            modelBuilder.Entity <Activity>()
            .HasMany(e => e.Plans)
            .WithMany(e => e.Activities)
            .Map(m => m.ToTable("PlanActivity").MapLeftKey("ActivityID").MapRightKey("PlanID"));

            modelBuilder.Entity <Place>()
            .Property(e => e.PlaceName)
            .IsUnicode(false);

            modelBuilder.Entity <Place>()
            .Property(e => e.PlaceAddress)
            .IsUnicode(false);

            modelBuilder.Entity <Place>()
            .Property(e => e.Phone)
            .IsUnicode(false);

            modelBuilder.Entity <PlaceType>()
            .Property(e => e.PlaceType1)
            .IsUnicode(false);

            modelBuilder.Entity <PlanCriteria>()
            .Property(e => e.PlanType)
            .IsUnicode(false);

            modelBuilder.Entity <PlanCriteria>()
            .Property(e => e.GroupOfFriends)
            .IsUnicode(false);

            modelBuilder.Entity <PlanCriteria>()
            .Property(e => e.CurrentLocation)
            .IsUnicode(false);

            modelBuilder.Entity <PlanCriteria>()
            .Property(e => e.UserLifeStyle)
            .IsUnicode(false);

            modelBuilder.Entity <Plan>()
            .Property(e => e.PlanName)
            .IsUnicode(false);

            modelBuilder.Entity <Plan>()
            .Property(e => e.PlanType)
            .IsUnicode(false);

            modelBuilder.Entity <Question>()
            .Property(e => e.QS)
            .IsUnicode(false);

            modelBuilder.Entity <Survey>()
            .Property(e => e.SurveyName)
            .IsUnicode(false);

            modelBuilder.Entity <User>()
            .Property(e => e.UserSurname)
            .IsUnicode(false);

            modelBuilder.Entity <User>()
            .Property(e => e.UserName)
            .IsUnicode(false);

            modelBuilder.Entity <User>()
            .Property(e => e.UserLifeStyle)
            .IsUnicode(false);

            modelBuilder.Entity <User>()
            .Property(e => e.Gender)
            .IsUnicode(false);

            modelBuilder.Entity <User>()
            .Property(e => e.Email)
            .IsUnicode(false);

            modelBuilder.Entity <User>()
            .Property(e => e.Phone)
            .IsUnicode(false);

            modelBuilder.Entity <User>()
            .Property(e => e.UserAddress)
            .IsUnicode(false);

            modelBuilder.Entity <User>()
            .Property(e => e.Job)
            .IsUnicode(false);

            modelBuilder.Entity <User>()
            .HasMany(e => e.Accounts)
            .WithRequired(e => e.User)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <PlaceOwner>()
            .Property(e => e.PlaceOwnerName)
            .IsUnicode(false);

            modelBuilder.Entity <PlaceOwner>()
            .Property(e => e.PlaceOwnerSurname)
            .IsUnicode(false);

            modelBuilder.Entity <PlaceOwner>()
            .Property(e => e.Gender)
            .IsUnicode(false);

            modelBuilder.Entity <PlaceOwner>()
            .Property(e => e.Phone)
            .IsUnicode(false);
        }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Entity<Doctor>()
         .Property(e => e.Sex)
         .IsFixedLength();
 }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Configurations.Add(new CustomBannerRecordMap());
     base.OnModelCreating(modelBuilder);
 }
Exemple #52
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity <TB_AG_BANCO>()
            .Property(e => e.NRO_AGENCIA)
            .IsUnicode(false);

            modelBuilder.Entity <TB_AG_BANCO>()
            .Property(e => e.DV_AGENCIA)
            .IsUnicode(false);

            modelBuilder.Entity <TB_AG_BANCO>()
            .Property(e => e.GERENTE)
            .IsUnicode(false);

            modelBuilder.Entity <TB_AG_BANCO>()
            .Property(e => e.GERENTE_REL)
            .IsUnicode(false);

            modelBuilder.Entity <TB_AG_BANCO>()
            .Property(e => e.STATUS_AG_BANCO)
            .IsFixedLength()
            .IsUnicode(false);

            modelBuilder.Entity <TB_BANCO>()
            .Property(e => e.NUM_BANCO)
            .IsUnicode(false);

            modelBuilder.Entity <TB_BANCO>()
            .Property(e => e.NOME_CURTO)
            .IsUnicode(false);

            modelBuilder.Entity <TB_BANCO>()
            .Property(e => e.NOME)
            .IsUnicode(false);

            modelBuilder.Entity <TB_BANCO>()
            .Property(e => e.STATUS_BANCO)
            .IsFixedLength()
            .IsUnicode(false);

            modelBuilder.Entity <TB_BANCO>()
            .HasMany(e => e.TB_AG_BANCO)
            .WithRequired(e => e.TB_BANCO)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <TB_MUNICIPIO>()
            .Property(e => e.COD_IBGE)
            .IsUnicode(false);

            modelBuilder.Entity <TB_MUNICIPIO>()
            .Property(e => e.NOME_MUN)
            .IsUnicode(false);

            modelBuilder.Entity <TB_PAIS>()
            .Property(e => e.COD_IBGE)
            .IsUnicode(false);

            modelBuilder.Entity <TB_PAIS>()
            .Property(e => e.SIGLA_PAIS)
            .IsUnicode(false);

            modelBuilder.Entity <TB_PAIS>()
            .Property(e => e.NOME_PAIS)
            .IsUnicode(false);

            modelBuilder.Entity <TB_UF>()
            .Property(e => e.COD_IBGE)
            .IsUnicode(false);

            modelBuilder.Entity <TB_UF>()
            .Property(e => e.SIGLA)
            .IsUnicode(false);

            modelBuilder.Entity <TB_UF>()
            .Property(e => e.NOME_UF)
            .IsUnicode(false);

            modelBuilder.Entity <TB_UF>()
            .HasMany(e => e.TB_MUNICIPIO)
            .WithRequired(e => e.TB_UF)
            .WillCascadeOnDelete(false);
        }
Exemple #53
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Conventions.Remove <OneToManyCascadeDeleteConvention>();
     base.OnModelCreating(modelBuilder);
 }
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Conventions.Remove <OneToManyCascadeDeleteConvention>();//isto e para desactivar a regra casacate deleting rule
     //Desactiva a convencao/regra
 }
Exemple #55
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            // Needed to ensure subclasses share the same table
            var user = modelBuilder.Entity <Admin>()
                       .ToTable("Admin");

            user.Property(u => u.UserName)
            .IsRequired()
            .HasMaxLength(256)
            .HasColumnAnnotation("Index", new IndexAnnotation(new IndexAttribute("UserNameIndex")
            {
                IsUnique = true
            }));
            user.Property(u => u.Email)
            .HasMaxLength(256)
            .HasColumnAnnotation("Index", new IndexAnnotation(new IndexAttribute("UserEmailIndex")
            {
                IsUnique = true
            }));
            user.HasMany(u => u.Roles).WithRequired().HasForeignKey(ur => ur.UserId);
            user.HasMany(u => u.Claims).WithRequired().HasForeignKey(uc => uc.UserId);
            user.HasMany(u => u.Logins).WithRequired().HasForeignKey(ul => ul.UserId);

            modelBuilder.Entity <AdminRole>()
            .HasKey(r => new { r.UserId, r.RoleId })
            .ToTable("AdminRole");

            modelBuilder.Entity <AdminLogin>()
            .HasKey(l => new { l.LoginProvider, l.ProviderKey, l.UserId })
            .ToTable("AdminLogin");

            modelBuilder.Entity <AdminClaim>()
            .ToTable("AdminClaim");

            var role = modelBuilder.Entity <RoleForAdmin>()
                       .ToTable("RoleForAdmin");

            role.Property(r => r.Name)
            .IsRequired()
            .HasMaxLength(256)
            .HasColumnAnnotation("Index", new IndexAnnotation(new IndexAttribute("RoleNameIndex")
            {
                IsUnique = true
            }));
            role.HasMany(r => r.Users).WithRequired().HasForeignKey(ur => ur.RoleId);



            var client = modelBuilder.Entity <User>()
                         .ToTable("User");

            client.Property(u => u.UserName)
            .IsRequired()
            .HasMaxLength(256)
            .HasColumnAnnotation("Index", new IndexAnnotation(new IndexAttribute("UserNameIndex")
            {
                IsUnique = true
            }));
            client.Property(u => u.Email)
            .HasMaxLength(256)
            .HasColumnAnnotation("Index", new IndexAnnotation(new IndexAttribute("UserEmailIndex")
            {
                IsUnique = true
            }));
            client.HasMany(u => u.Roles).WithRequired().HasForeignKey(ur => ur.UserId);
            client.HasMany(u => u.Claims).WithRequired().HasForeignKey(uc => uc.UserId);
            client.HasMany(u => u.Logins).WithRequired().HasForeignKey(ul => ul.UserId);

            modelBuilder.Entity <UserRole>()
            .HasKey(r => new { r.UserId, r.RoleId })
            .ToTable("UserRole");

            modelBuilder.Entity <UserLogin>()
            .HasKey(l => new { l.LoginProvider, l.ProviderKey, l.UserId })
            .ToTable("UserLogin");

            modelBuilder.Entity <UserClaim>()
            .ToTable("UserClaim");

            var roleclient = modelBuilder.Entity <RoleForUser>()
                             .ToTable("RoleForUser");

            roleclient.Property(r => r.Name)
            .IsRequired()
            .HasMaxLength(256)
            .HasColumnAnnotation("Index", new IndexAnnotation(new IndexAttribute("RoleNameIndex")
            {
                IsUnique = true
            }));
            roleclient.HasMany(r => r.Users).WithRequired().HasForeignKey(ur => ur.RoleId);


            //modelBuilder.Entity<Badge>()
            //   .HasMany(e => e.Achievements)
            //   .WithOptional(e => e.Badge)
            //   .HasForeignKey(e => e.AchivedBadge);

            //modelBuilder.Entity<Badge>()
            //    .HasMany(e => e.BadgeIcons)
            //    .WithRequired(e => e.Badge)
            //    .WillCascadeOnDelete(false);

            //modelBuilder.Entity<Challenge>()
            //    .HasMany(e => e.Achievements)
            //    .WithOptional(e => e.Challenge)
            //    .HasForeignKey(e => e.AchivedChallenge);



            //modelBuilder.Entity<Icon>()
            //    .HasMany(e => e.BadgeIcons)
            //    .WithRequired(e => e.Icon)
            //    .WillCascadeOnDelete(false);

            //modelBuilder.Entity<Icon>()
            //    .HasMany(e => e.LevelIcons)
            //    .WithRequired(e => e.Icon)
            //    .WillCascadeOnDelete(false);

            //modelBuilder.Entity<IconType>()
            //    .HasMany(e => e.Icons)
            //    .WithRequired(e => e.IconType1)
            //    .HasForeignKey(e => e.IconType)
            //    .WillCascadeOnDelete(false);

            //modelBuilder.Entity<Level>()
            //    .HasMany(e => e.Achievements)
            //    .WithOptional(e => e.Level)
            //    .HasForeignKey(e => e.AchivedLevel);

            //modelBuilder.Entity<Level>()
            //    .HasMany(e => e.Achievements)
            //    .WithOptional(e => e.Level)
            //    .HasForeignKey(e => e.AchivedLevel);
            //        modelBuilder.Entity<Achievement>()
            //         .HasRequired(e => e.LevelAfter)
            //           .WithMany()
            //.WillCascadeOnDelete(false);



            //modelBuilder.Entity<Level>()
            //    .HasMany(e => e.LevelIcons)
            //    .WithRequired(e => e.Level)
            //    .WillCascadeOnDelete(false);
        }
Exemple #56
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity <application>()
            .Property(e => e.Description)
            .IsUnicode(false);

            modelBuilder.Entity <application>()
            .Property(e => e.state)
            .IsUnicode(false);

            modelBuilder.Entity <application>()
            .HasMany(e => e.interviews)
            .WithOptional(e => e.application)
            .HasForeignKey(e => e.application_id);

            modelBuilder.Entity <application>()
            .HasMany(e => e.applicationtests)
            .WithRequired(e => e.application)
            .HasForeignKey(e => e.application_id)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <client>()
            .Property(e => e.email)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .Property(e => e.first_name)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .Property(e => e.last_name)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .Property(e => e.note)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .Property(e => e.password)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .Property(e => e.photo)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .Property(e => e.role)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .Property(e => e.token)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .Property(e => e.username)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .Property(e => e.category)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .Property(e => e.name)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .Property(e => e.type)
            .IsUnicode(false);

            modelBuilder.Entity <client>()
            .HasMany(e => e.projects)
            .WithOptional(e => e.client)
            .HasForeignKey(e => e.client_id);

            modelBuilder.Entity <client>()
            .HasMany(e => e.requests)
            .WithMany(e => e.clients)
            .Map(m => m.ToTable("client_request").MapLeftKey("clients_id").MapRightKey("requests_id"));

            modelBuilder.Entity <conversation>()
            .Property(e => e.state)
            .IsUnicode(false);

            modelBuilder.Entity <conversation>()
            .HasMany(e => e.messages)
            .WithOptional(e => e.conversation1)
            .HasForeignKey(e => e.conversation);

            modelBuilder.Entity <folder>()
            .Property(e => e.stateFolder)
            .IsUnicode(false);

            modelBuilder.Entity <folder>()
            .Property(e => e.stateLetter)
            .IsUnicode(false);

            modelBuilder.Entity <folder>()
            .Property(e => e.stateMinister)
            .IsUnicode(false);

            modelBuilder.Entity <folder>()
            .HasMany(e => e.applications)
            .WithOptional(e => e.folder)
            .HasForeignKey(e => e.folder_id);

            modelBuilder.Entity <folder>()
            .HasMany(e => e.letters)
            .WithOptional(e => e.folder)
            .HasForeignKey(e => e.folder_id);

            modelBuilder.Entity <interview>()
            .Property(e => e.stateInterview)
            .IsUnicode(false);

            modelBuilder.Entity <interview>()
            .Property(e => e.typeInterview)
            .IsUnicode(false);

            modelBuilder.Entity <joboffer>()
            .Property(e => e.experience)
            .IsUnicode(false);

            modelBuilder.Entity <joboffer>()
            .Property(e => e.function)
            .IsUnicode(false);

            modelBuilder.Entity <joboffer>()
            .Property(e => e.mission)
            .IsUnicode(false);

            modelBuilder.Entity <joboffer>()
            .Property(e => e.required_profile)
            .IsUnicode(false);

            modelBuilder.Entity <joboffer>()
            .HasMany(e => e.applications)
            .WithOptional(e => e.joboffer)
            .HasForeignKey(e => e.jobOffer_id);

            modelBuilder.Entity <joboffer>()
            .HasMany(e => e.skills)
            .WithOptional(e => e.joboffer)
            .HasForeignKey(e => e.jobOffer_id);

            modelBuilder.Entity <leave>()
            .Property(e => e.type)
            .IsUnicode(false);

            modelBuilder.Entity <letter>()
            .Property(e => e.contratType)
            .IsUnicode(false);

            modelBuilder.Entity <letter>()
            .Property(e => e.type)
            .IsUnicode(false);

            modelBuilder.Entity <message>()
            .Property(e => e.message1)
            .IsUnicode(false);

            modelBuilder.Entity <message>()
            .Property(e => e.subject)
            .IsUnicode(false);

            modelBuilder.Entity <message>()
            .Property(e => e.type)
            .IsUnicode(false);

            modelBuilder.Entity <project>()
            .Property(e => e.adress)
            .IsUnicode(false);

            modelBuilder.Entity <project>()
            .Property(e => e.name)
            .IsUnicode(false);

            modelBuilder.Entity <project>()
            .Property(e => e.photo)
            .IsUnicode(false);

            modelBuilder.Entity <project>()
            .Property(e => e.type)
            .IsUnicode(false);

            modelBuilder.Entity <project>()
            .HasMany(e => e.mandates)
            .WithOptional(e => e.project)
            .HasForeignKey(e => e.project_id);

            modelBuilder.Entity <project>()
            .HasMany(e => e.ressources)
            .WithOptional(e => e.project)
            .HasForeignKey(e => e.project_id);

            modelBuilder.Entity <question>()
            .Property(e => e.Subject)
            .IsUnicode(false);

            modelBuilder.Entity <question>()
            .Property(e => e.choice1)
            .IsUnicode(false);

            modelBuilder.Entity <question>()
            .Property(e => e.choice2)
            .IsUnicode(false);

            modelBuilder.Entity <question>()
            .Property(e => e.choice3)
            .IsUnicode(false);

            modelBuilder.Entity <question>()
            .Property(e => e.choice4)
            .IsUnicode(false);

            modelBuilder.Entity <question>()
            .Property(e => e.validChoise)
            .IsUnicode(false);

            modelBuilder.Entity <request>()
            .Property(e => e.context)
            .IsUnicode(false);

            modelBuilder.Entity <request>()
            .Property(e => e.resourceType)
            .IsUnicode(false);

            modelBuilder.Entity <request>()
            .HasMany(e => e.skills)
            .WithOptional(e => e.request)
            .HasForeignKey(e => e.request_id);

            modelBuilder.Entity <ressource>()
            .Property(e => e.email)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.first_name)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.last_name)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.note)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.password)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.photo)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.role)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.token)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.contract_type)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.profile)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.sector)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.seniority)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .Property(e => e.state)
            .IsUnicode(false);

            modelBuilder.Entity <ressource>()
            .HasMany(e => e.applications)
            .WithOptional(e => e.ressource)
            .HasForeignKey(e => e.ressource_id);

            modelBuilder.Entity <ressource>()
            .HasMany(e => e.leaves)
            .WithOptional(e => e.ressource)
            .HasForeignKey(e => e.ressource_id);

            modelBuilder.Entity <ressource>()
            .HasMany(e => e.mandates)
            .WithOptional(e => e.ressource)
            .HasForeignKey(e => e.ressource_id);

            modelBuilder.Entity <ressource>()
            .HasMany(e => e.ressource1)
            .WithOptional(e => e.ressource2)
            .HasForeignKey(e => e.assigned_id);

            modelBuilder.Entity <ressource>()
            .HasMany(e => e.skills)
            .WithOptional(e => e.ressource)
            .HasForeignKey(e => e.ressource_id);

            modelBuilder.Entity <skill>()
            .Property(e => e.name)
            .IsUnicode(false);

            modelBuilder.Entity <test>()
            .Property(e => e.typeTest)
            .IsUnicode(false);

            modelBuilder.Entity <test>()
            .Property(e => e.version)
            .IsUnicode(false);

            modelBuilder.Entity <test>()
            .HasMany(e => e.applicationtests)
            .WithRequired(e => e.test)
            .HasForeignKey(e => e.test_id)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <test>()
            .HasMany(e => e.questions)
            .WithMany(e => e.tests)
            .Map(m => m.ToTable("test_question").MapLeftKey("listTest_id").MapRightKey("listQuestion_id"));

            modelBuilder.Entity <user>()
            .Property(e => e.email)
            .IsUnicode(false);

            modelBuilder.Entity <user>()
            .Property(e => e.first_name)
            .IsUnicode(false);

            modelBuilder.Entity <user>()
            .Property(e => e.last_name)
            .IsUnicode(false);

            modelBuilder.Entity <user>()
            .Property(e => e.note)
            .IsUnicode(false);

            modelBuilder.Entity <user>()
            .Property(e => e.password)
            .IsUnicode(false);

            modelBuilder.Entity <user>()
            .Property(e => e.photo)
            .IsUnicode(false);

            modelBuilder.Entity <user>()
            .Property(e => e.role)
            .IsUnicode(false);

            modelBuilder.Entity <user>()
            .Property(e => e.token)
            .IsUnicode(false);
        }
Exemple #57
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     // remove the convention to make the table name the pluralised version of the model name
     modelBuilder.Conventions.Remove <PluralizingTableNameConvention>();
 }
Exemple #58
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Entity <ActualEntity2>().Property(e => e.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);
 }
Exemple #59
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity <City>()
            .Property(e => e.city1)
            .IsUnicode(false);

            modelBuilder.Entity <Country>()
            .Property(e => e.country1)
            .IsUnicode(false);

            modelBuilder.Entity <Country>()
            .Property(e => e.postalPattern)
            .IsUnicode(false);

            modelBuilder.Entity <Country>()
            .HasMany(e => e.Regions)
            .WithRequired(e => e.Country1)
            .HasForeignKey(e => e.country)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <Country>()
            .HasMany(e => e.Reservations)
            .WithRequired(e => e.Country1)
            .HasForeignKey(e => e.country)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <CreditCardType>()
            .Property(e => e.type)
            .IsUnicode(false);

            modelBuilder.Entity <CreditCardType>()
            .Property(e => e.cardNumberPattern)
            .IsUnicode(false);

            modelBuilder.Entity <CreditCardType>()
            .HasMany(e => e.Reservations)
            .WithRequired(e => e.CreditCardType1)
            .HasForeignKey(e => e.CreditCardType)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <Region>()
            .Property(e => e.region1)
            .IsUnicode(false);

            modelBuilder.Entity <Region>()
            .HasMany(e => e.Cities)
            .WithRequired(e => e.Region1)
            .HasForeignKey(e => e.region)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <Region>()
            .HasMany(e => e.Reservations)
            .WithRequired(e => e.Region1)
            .HasForeignKey(e => e.region)
            .WillCascadeOnDelete(false);

            modelBuilder.Entity <Reservation>()
            .Property(e => e.firstName)
            .IsUnicode(false);

            modelBuilder.Entity <Reservation>()
            .Property(e => e.lastName)
            .IsUnicode(false);

            modelBuilder.Entity <Reservation>()
            .Property(e => e.streetNumber)
            .IsUnicode(false);

            modelBuilder.Entity <Reservation>()
            .Property(e => e.streetName)
            .IsUnicode(false);

            modelBuilder.Entity <Reservation>()
            .Property(e => e.city)
            .IsUnicode(false);

            modelBuilder.Entity <Reservation>()
            .Property(e => e.postalCode)
            .IsUnicode(false);

            modelBuilder.Entity <Reservation>()
            .Property(e => e.phoneNumber)
            .IsUnicode(false);

            modelBuilder.Entity <Reservation>()
            .Property(e => e.emailAddress)
            .IsUnicode(false);

            modelBuilder.Entity <Reservation>()
            .Property(e => e.nameOnTheCard)
            .IsUnicode(false);

            modelBuilder.Entity <Reservation>()
            .Property(e => e.CreditCardnumber)
            .IsUnicode(false);

            modelBuilder.Entity <Room>()
            .Property(e => e.roomNumber)
            .IsUnicode(false);

            modelBuilder.Entity <RoomType>()
            .Property(e => e.roomType1)
            .IsUnicode(false);

            modelBuilder.Entity <RoomType>()
            .HasMany(e => e.Reservations)
            .WithRequired(e => e.RoomType1)
            .HasForeignKey(e => e.roomType)
            .WillCascadeOnDelete(false);
        }
Exemple #60
0
 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Conventions.Remove <PluralizingTableNameConvention>();
 }