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

        }

        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);
        }

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

         //   modelBuilder.Entity<Employee>().H
        }

        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");
        }

 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());
 }

 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<Feature>()
         .HasMany(e => e.Feedback)
         .WithRequired(e => e.Feature)
         .WillCascadeOnDelete(false);
 }

 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);
 }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

            modelBuilder.Configurations.Add(new JobInfoMap());
            base.OnModelCreating(modelBuilder);
        }

        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());
 }

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

            modelBuilder.Conventions.Add(new DateTimePrecisionAttributeConvention());
            modelBuilder.Conventions.Add(new DecimalPrecisionAttributeConvention());
        }

        /// <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)
        {
            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);
        }

        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)
 {
     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.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);
 }

        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);
        }

        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<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);
        }