Esempio n. 1
0
 public static void BuildWebModel(System.Data.Entity.DbModelBuilder modelBuilder)
 {
     // Note: Only use concrete types.
     modelBuilder.Entity<Event>();
     modelBuilder.Entity<Person>();
     modelBuilder.Entity<ReservationResult>();
 }
Esempio n. 2
0
        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Employee>().ToTable("Employees");
            modelBuilder.Entity<Employee>().HasKey(p => p.ADLoginID).Property(p => p.ADLoginID).HasDatabaseGeneratedOption(System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.None);
            modelBuilder.Entity<Employee>().Ignore(p => p.AreaDetails);

            modelBuilder.Entity<BusinessObjects.WorkManagement.Skill>().ToTable("EmployeeSkills");
            modelBuilder.Entity<BusinessObjects.WorkManagement.Skill>().HasKey(p => p.ID).Property(p => p.ID).HasDatabaseGeneratedOption(System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.None);

            modelBuilder.Entity<BusinessObjects.WorkManagement.Skill>().Property(p => p.ID).HasColumnName("SkillID");
            modelBuilder.Entity<BusinessObjects.WorkManagement.Skill>().Property(p => p.Code).HasColumnName("SkillCode");
            modelBuilder.Entity<BusinessObjects.WorkManagement.Skill>().Property(p => p.Description).HasColumnName("SkillDesc");

            modelBuilder.Entity<BusinessObjects.WorkManagement.Skill>().Ignore(p => p.IsDirty);
            modelBuilder.Entity<BusinessObjects.WorkManagement.Skill>().Ignore(p => p.IsNew);
            modelBuilder.Entity<BusinessObjects.WorkManagement.Skill>().Ignore(p => p.NoOfWorkersRequired);
            modelBuilder.Entity<BusinessObjects.WorkManagement.Skill>().Ignore(p => p.SourceSystems);
            modelBuilder.Entity<BusinessObjects.WorkManagement.Skill>().Ignore(p => p.StandardHours);

            modelBuilder.Entity<PostCodeResponsibility>().HasKey(p => p.ID).Property(p => p.ID).HasDatabaseGeneratedOption(System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.Identity);
            modelBuilder.Entity<PostCodeResponsibility>().Property(p => p.ID).HasColumnName("ResponsibilityID");

            modelBuilder.Entity<Employee>().HasMany<BusinessObjects.WorkManagement.Skill>(p => p.Skills);
            modelBuilder.Entity<Employee>().HasMany<PostCodeResponsibility>(p => p.PostCodeResponsibilities);

            // AreaDetails is working due to following a Convention. Attempted to define explicitly, varyimng MapKey as per below, but did NOT work....
            // modelBuilder.Entity<Employee>().HasRequired(p => p.AreaDetails).WithMany().Map(p => p.MapKey("AreaDetails_ID")); // AreaDetails_AreaID

            base.OnModelCreating(modelBuilder);
        }
Esempio n. 3
0
 protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
 {
     modelBuilder.Entity<Dinner>().HasMany(r => r.Meals);
     modelBuilder.Entity<User>().HasMany(r => r.Roles);
     modelBuilder.Entity<Vendor>().HasMany(r => r.Coupons);
     base.OnModelCreating(modelBuilder);
 }
        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            //configure primary keys first
            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Attendence>().HasKey(p=>p.AttendenceId);
            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Attendence>()
                .HasRequired(p => p.Student).WithMany(p => p.Attendences).HasForeignKey(p => p.StudentId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Attendence>()
                .HasRequired(p => p.Course).WithMany(p => p.Attendences).HasForeignKey(p=>p.CourseId);


            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Attendence>()
                .HasRequired(p => p.TimeTable).WithMany().HasForeignKey(p=>p.TimeTableId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Course>().HasKey(p=>p.CourseId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.CourseScedule>().HasKey(p=>p.CourseSceduleId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.CourseScedule>().HasRequired(p => p.TimeTable).WithMany().HasForeignKey(p=>p.TimeTableId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Department>().HasKey(p => p.DepartmentId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Department>().HasRequired(p => p.FileStorage).WithMany().HasForeignKey(p=>p.FileStorageId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.DepartmentCourse>().HasKey(p=>p.DepartmentCourseId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.DepartmentCourse>().HasRequired(p => p.Department).WithMany().HasForeignKey(p=>p.DepartmentId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.DepartmentCourse>().HasRequired(p => p.Course).WithMany().HasForeignKey(p=>p.CourseId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Employee>().HasKey(p=>p.EmployeeId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Event>().HasKey(p=>p.EventId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Event>().HasRequired(p => p.EventTime).WithMany().HasForeignKey(p=>p.EventTimeTableId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.FileStorage>().HasKey(p=>p.FileStorageId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Grade>().HasKey(p=>p.GradeId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.News>().HasKey(p=>p.NewsId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Result>().HasKey(p=>p.ResultId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Result>().HasRequired(p => p.Student).WithMany().HasForeignKey(p=>p.StudentId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Result>().HasRequired(p => p.Course).WithMany().HasForeignKey(p=>p.CourseId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Result>().HasRequired(p => p.TimeTable).WithMany().HasForeignKey(p=>p.TimeTableId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.Student>().HasKey(p => p.StudentId);

            modelBuilder.Entity<University.Service.Areas.HelpPage.Models.User>().HasOptional(p => p.UserRole).WithMany(p => p.Users).HasForeignKey(p=>p.UserRoleId);

            modelBuilder.Entity<IdentityUserLogin>().HasKey<string>(l => l.UserId);
            
            modelBuilder.Entity<IdentityRole>().HasKey<string>(r => r.Id);

            modelBuilder.Entity<IdentityUserRole>().HasKey(r => new { r.RoleId, r.UserId });
        }
 protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
 {
     modelBuilder.Configurations.Add(new ConfiguracaoLivraria());
     modelBuilder.Entity<Livro>().HasKey(l => l.ISBN).ToTable("Livros");
     modelBuilder.Entity<Autor>().HasKey(a => a.AutorID).ToTable("Autores");
     modelBuilder.Entity<Editora>().HasKey(a => a.EditoraID).ToTable("Editoras");
 }
Esempio n. 6
0
 protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
 {
     modelBuilder.Conventions.Remove<IncludeMetadataConvention>();
     modelBuilder.Entity<Genre>().ToTable("Genre");
     modelBuilder.Entity<Album>().ToTable("Album");
     base.OnModelCreating(modelBuilder);
 }
        public void MapEntity(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<MusicBrainzInformation>()
                .Property(t => t.Id).HasColumnName("Id");
            modelBuilder.Entity<MusicBrainzInformation>()
                .Property(t => t.AlbumId).HasColumnName("AlbumId");
            modelBuilder.Entity<MusicBrainzInformation>()
                .Property(t => t.ArtistId).HasColumnName("ArtistId");
            modelBuilder.Entity<MusicBrainzInformation>()
                .Property(t => t.ArtistMBId).HasColumnName("ArtistMBId").IsUnicode(false);
            modelBuilder.Entity<MusicBrainzInformation>()
                .Property(t => t.AlbumMBId).HasColumnName("AlbumMBId").IsUnicode(false);
            modelBuilder.Entity<MusicBrainzInformation>()
                .Property(t => t.Title).HasColumnName("Title").IsUnicode(false);
            modelBuilder.Entity<MusicBrainzInformation>()
                .Property(t => t.TitleMBId).HasColumnName("TitleMBId").IsUnicode(false);

            modelBuilder.Entity<MusicBrainzInformation>()
                        .HasRequired<Album>(t => t.Album)
                        .WithMany()
                        .HasForeignKey(e => e.AlbumId);
            modelBuilder.Entity<MusicBrainzInformation>()
                        .HasRequired<Interpret>(t => t.Artist)
                        .WithMany()
                        .HasForeignKey(e => e.ArtistId);
        }
Esempio n. 8
0
        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            /*modelBuilder.Entity<ResoultSaveModel>().HasKey(i => i.Id);
            modelBuilder.Entity<ResoultSaveModel>().Property(i => i.Mark);
            modelBuilder.Entity<ResoultSaveModel>().Property(i => i.UserName);
            modelBuilder.Entity<ResoultSaveModel>().Property(i => i.Started);
            modelBuilder.Entity<ResoultSaveModel>().Property(i => i.Finished);*/

            modelBuilder.Entity<TestModel>().HasKey(i => i.Id);
            modelBuilder.Entity<TestModel>().Property(i => i.title);
            modelBuilder.Entity<TestModel>().Property(i => i.Description);

            modelBuilder.Entity<TestModel>().HasMany(i => i.Questions)
                .WithRequired()
                .HasForeignKey(si => si.TestId);

            modelBuilder.Entity<Question>().HasKey(i => i.QuestionId);
            modelBuilder.Entity<Question>().Property(i => i.Text);

            modelBuilder.Entity<Question>().HasMany(i => i.Answers)
                .WithRequired()
                .HasForeignKey(si => si.QuestionId);

            modelBuilder.Entity<AnswerVariant>().HasKey(i => i.AnswerId);
            modelBuilder.Entity<AnswerVariant>().Property(i => i.Text);
        }
Esempio n. 9
0
        public void MapEntity(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Album>()
                .Property(t => t.Name).HasColumnName("Name").IsUnicode(false);
            modelBuilder.Entity<Album>()
                .Property(t => t.Searchname).HasColumnName("Searchname");
            modelBuilder.Entity<Album>()
                .Property(t => t.InformationStatus).HasColumnName("AdditionalStatus");

            modelBuilder.Entity<Album>()
                        .HasMany<Title>(t => t.Titles)
                        .WithRequired(e => e.Album)
                        .HasForeignKey(e => e.AlbumId);
        }
Esempio n. 10
0
        public void MapEntity(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Interpret>()
                .Property(t => t.Id).HasColumnName("Id");
            modelBuilder.Entity<Interpret>()
                .Property(t => t.Name).HasColumnName("Name").IsUnicode(false);
            modelBuilder.Entity<Interpret>()
                .Property(t => t.Searchname).HasColumnName("Searchname");

            modelBuilder.Entity<Interpret>()
                        .HasMany<Title>(t => t.Titles)
                        .WithRequired(e => e.Interpret)
                        .HasForeignKey(e => e.InterpretId);

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

            // A bit hacky way to provide default values for properties not needed for tests but still satisfy constraints.
            modelBuilder.RegisterEntityType(typeof(TestCurrency));
            modelBuilder.RegisterEntityType(typeof(TestAuction));
            modelBuilder.RegisterEntityType(typeof(TestBuyOffer));
            modelBuilder.RegisterEntityType(typeof(TestCategory));
            modelBuilder.RegisterEntityType(typeof(TestUser));

            modelBuilder.Entity<TestAuction>().Property(x => x.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);
            modelBuilder.Entity<TestBuyOffer>().Property(x => x.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);
            modelBuilder.Entity<TestCategory>().Property(x => x.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);
            modelBuilder.Entity<TestUser>().Property(x => x.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);
        }
        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {

          

            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
            modelBuilder.Entity<Person>().MapToStoredProcedures();
            //modelBuilder.HasDefaultSchema("public");
            modelBuilder.Configurations.Add(new PersonConfiguration());
            //modelBuilder.Configurations.AddFromAssembly(Assembly.GetExecutingAssembly());
            base.OnModelCreating(modelBuilder);
            // modelBuilder.Conventions.Remove)
        }
Esempio n. 13
0
        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<AreaPostCode>().HasKey(p => p.ID).Property(p => p.ID).HasDatabaseGeneratedOption(System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.Identity);
            modelBuilder.Entity<AreaPostCode>().Property(p => p.ID).HasColumnName("AreaPostCodeID");

            modelBuilder.Entity<PrimaryArea>().HasKey(p => p.ID).Property(p => p.ID).HasDatabaseGeneratedOption(System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.Identity);
            modelBuilder.Entity<PrimaryArea>().Property(p => p.ID).HasColumnName("PrimaryAreaID");
            modelBuilder.Entity<PrimaryArea>().Property(p => p.Name).HasColumnName("AreaName");

            modelBuilder.Entity<SubArea>().HasKey(p => p.ID).Property(p => p.ID).HasDatabaseGeneratedOption(System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.Identity);
            modelBuilder.Entity<SubArea>().Property(p => p.ID).HasColumnName("SubAreaID");
            modelBuilder.Entity<SubArea>().Property(p => p.Name).HasColumnName("AreaName");

            base.OnModelCreating(modelBuilder);
        }
Esempio n. 14
0
 protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
 {
     Database.SetInitializer<AccountDBContext>(null);
     modelBuilder.Entity<User>()
         .HasMany(e => e.Roles)
         .WithMany(e => e.Users)
         .Map(m =>
         {
             m.ToTable("UserRole");
             m.MapLeftKey("UserID");
             m.MapRightKey("RoleID");
         });
     base.OnModelCreating(modelBuilder);
 }
        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

            InheritanceMapping(modelBuilder);

            #region CategoryLink

            modelBuilder.Entity<dataModel.CategoryRelation>().HasKey(x => x.Id)
                    .Property(x => x.Id);

            modelBuilder.Entity<dataModel.CategoryRelation>().HasOptional(x => x.TargetCategory)
                                       .WithMany(x => x.IncommingLinks)
                                       .HasForeignKey(x => x.TargetCategoryId).WillCascadeOnDelete(false);

            modelBuilder.Entity<dataModel.CategoryRelation>().HasRequired(x => x.SourceCategory)
                                       .WithMany(x => x.OutgoingLinks)
                                       .HasForeignKey(x => x.SourceCategoryId).WillCascadeOnDelete(false);

            modelBuilder.Entity<dataModel.CategoryRelation>().HasOptional(x => x.TargetCatalog)
                                       .WithMany(x => x.IncommingLinks)
                                       .HasForeignKey(x => x.TargetCatalogId).WillCascadeOnDelete(false);

            modelBuilder.Entity<dataModel.CategoryRelation>().ToTable("CategoryRelation");
            #endregion

            MapEntity<dataModel.CategoryItemRelation>(modelBuilder, toTable: "CategoryItemRelation");
            MapEntity<dataModel.Association>(modelBuilder, toTable: "Association");
            MapEntity<dataModel.AssociationGroup>(modelBuilder, toTable: "AssociationGroup");
            MapEntity<dataModel.CatalogLanguage>(modelBuilder, toTable: "CatalogLanguage");
            MapEntity<dataModel.EditorialReview>(modelBuilder, toTable: "EditorialReview");
            MapEntity<dataModel.ItemRelation>(modelBuilder, toTable: "ItemRelation");
            MapEntity<dataModel.Property>(modelBuilder, toTable: "Property");
            MapEntity<dataModel.PropertyAttribute>(modelBuilder, toTable: "PropertyAttribute");
            MapEntity<dataModel.PropertySet>(modelBuilder, toTable: "PropertySet");
            MapEntity<dataModel.PropertySetProperty>(modelBuilder, toTable: "PropertySetProperty");


			#region Category
			modelBuilder.Entity<dataModel.Category>().HasKey(x => x.Id)
					.Property(x => x.Id);
			modelBuilder.Entity<dataModel.Category>().HasMany(c => c.Images).WithOptional(p => p.Category).HasForeignKey(x => x.CategoryId).WillCascadeOnDelete(true);
			modelBuilder.Entity<dataModel.Category>().HasOptional(x=>x.ParentCategory).WithMany().HasForeignKey(x => x.ParentCategoryId).WillCascadeOnDelete(false);
			modelBuilder.Entity<dataModel.Category>().ToTable("Category"); 
			#endregion

			modelBuilder.Entity<dataModel.Image>().ToTable("CatalogImage");
			modelBuilder.Entity<dataModel.Asset>().ToTable("CatalogAsset");

            // Introducing FOREIGN KEY constraint 'FK_dbo.Association_dbo.Item_ItemId' on table 'Association' may cause cycles or multiple cascade paths.
            modelBuilder.Entity<dataModel.Association>().HasRequired(m => m.CatalogItem).WithMany().WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.CategoryItemRelation>().HasRequired(p => p.Category).WithMany().WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.ItemRelation>().HasRequired(m => m.ChildItem).WithMany().WillCascadeOnDelete(false);
            // cascade delete Item and Category when PropertySet is deleted. This should happen ONLY when catalog is being deleted.
            modelBuilder.Entity<dataModel.Item>().HasOptional(m => m.PropertySet).WithMany().WillCascadeOnDelete(false);
			modelBuilder.Entity<dataModel.Item>().HasOptional(m => m.Category).WithMany().WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.Category>().HasOptional(m => m.PropertySet).WithMany().WillCascadeOnDelete(true);
            modelBuilder.Entity<dataModel.Catalog>().HasOptional(m => m.PropertySet).WithMany().WillCascadeOnDelete(true);
			modelBuilder.Entity<dataModel.CatalogPropertyValue>().HasRequired(m => m.Catalog).WithMany(x=>x.CatalogPropertyValues)
																 .HasForeignKey(x=>x.CatalogId).WillCascadeOnDelete(true);
			modelBuilder.Entity<dataModel.CategoryPropertyValue>().HasRequired(m => m.Category).WithMany(x => x.CategoryPropertyValues)
																 .HasForeignKey(x => x.CategoryId).WillCascadeOnDelete(true);
		



            base.OnModelCreating(modelBuilder);
        }
 protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
 {
   base.OnModelCreating(modelBuilder);
   modelBuilder.Entity<HistoryRow>().HasKey(h => new { h.MigrationId });
 }
Esempio n. 17
0
 //methods
 protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
 {
     modelBuilder.Entity<User>().HasKey(u => u.UserName);
     modelBuilder.Entity<Group>().HasKey(g => g.Id);
 }
 protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
 {
     base.OnModelCreating(modelBuilder);
     modelBuilder.Entity<HistoryRow>().Property(h => h.MigrationId).HasMaxLength(100).IsRequired();
     modelBuilder.Entity<HistoryRow>().Property(h => h.ContextKey).HasMaxLength(200).IsRequired();
 }
 protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
 {
     modelBuilder.Entity<ArchivedIncident>();
     modelBuilder.Entity<IncidentType>();
     modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
 }
Esempio n. 20
0
        //////////////////////////////
        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            modelBuilder.HasDefaultSchema("Tropica");

            modelBuilder.Entity<ApplicationUserLogin>().Map(c =>
            {
                c.ToTable("DefaultAsp_UserLogin");
                c.Properties(p => new
                {
                    p.UserId,
                    p.LoginProvider,
                    p.ProviderKey
                });
            }).HasKey(p => new { p.LoginProvider, p.ProviderKey, p.UserId });

            // Mapping for ApiRole
            modelBuilder.Entity<ApplicationRole>().Map(c =>
            {
                c.ToTable("DefaultAsp_Role");
                c.Property(p => p.Id).HasColumnName("RoleId");
                c.Properties(p => new
                {
                    p.Name
                });
            }).HasKey(p => p.Id);
            modelBuilder.Entity<ApplicationRole>().HasMany(c => c.Users).WithRequired().HasForeignKey(c => c.RoleId);

            modelBuilder.Entity<ApplicationUser>().Map(c =>
            {
                c.ToTable("User");
                c.Property(p => p.Id).HasColumnName("UserId");
                c.Properties(p => new
                {
                    p.AccessFailedCount,
                    p.Email,
                    p.EmailConfirmed,
                    p.PasswordHash,
                    p.PhoneNumber,
                    p.PhoneNumberConfirmed,
                    p.TwoFactorEnabled,
                    p.SecurityStamp,
                    p.LockoutEnabled,
                    p.LockoutEndDateUtc,
                    p.UserName
                });
            }).HasKey(c => c.Id);
            modelBuilder.Entity<ApplicationUser>().HasMany(c => c.Logins).WithOptional().HasForeignKey(c => c.UserId);
            modelBuilder.Entity<ApplicationUser>().HasMany(c => c.Claims).WithOptional().HasForeignKey(c => c.UserId);
            modelBuilder.Entity<ApplicationUser>().HasMany(c => c.Roles).WithRequired().HasForeignKey(c => c.UserId);

            modelBuilder.Entity<ApplicationUserRole>().Map(c =>
            {
                c.ToTable("DefaultAsp_UserRole");
                c.Properties(p => new
                {
                    p.UserId,
                    p.RoleId
                });
            })
            .HasKey(c => new { c.UserId, c.RoleId });

            modelBuilder.Entity<ApplicationUserClaim>().Map(c =>
            {
                c.ToTable("DefaultAsp_UserClaim");
                c.Property(p => p.Id).HasColumnName("UserClaimId");
                c.Properties(p => new
                {
                    p.UserId,
                    p.ClaimValue,
                    p.ClaimType
                });
            }).HasKey(c => c.Id);
        }
Esempio n. 21
0
        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

            modelBuilder.Entity<TwitterUser>()
                .HasRequired(a => a.rUser)
                .WithMany(a => a.TwitterUsers)
                .HasForeignKey(a => a.UserId);

            modelBuilder.Entity<TwitterFriends>().HasKey(m => new { m.FriendId, m.OwnerId });
        }
		/// <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(System.Data.Entity.DbModelBuilder modelBuilder)
		{
			modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

			InheritanceMapping(modelBuilder);

			MapEntity<CategoryItemRelation>(modelBuilder, toTable: "CategoryItemRelation");
			MapEntity<ItemAsset>(modelBuilder, toTable: "ItemAsset");
			MapEntity<Association>(modelBuilder, toTable: "Association");
			MapEntity<AssociationGroup>(modelBuilder, toTable: "AssociationGroup");
			MapEntity<CatalogLanguage>(modelBuilder, toTable: "CatalogLanguage");
			MapEntity<EditorialReview>(modelBuilder, toTable: "EditorialReview");
			MapEntity<ItemRelation>(modelBuilder, toTable: "ItemRelation");
			MapEntity<Price>(modelBuilder, toTable: "Price");
			MapEntity<Pricelist>(modelBuilder, toTable: "Pricelist");
			MapEntity<PricelistAssignment>(modelBuilder, toTable: "PricelistAssignment");
			MapEntity<Property>(modelBuilder, toTable: "Property");
			MapEntity<PropertyAttribute>(modelBuilder, toTable: "PropertyAttribute");
			MapEntity<PropertySet>(modelBuilder, toTable: "PropertySet");
			MapEntity<PropertySetProperty>(modelBuilder, toTable: "PropertySetProperty");
			MapEntity<Packaging>(modelBuilder, toTable: "Packaging");
			MapEntity<TaxCategory>(modelBuilder, toTable: "TaxCategory");

			// Introducing FOREIGN KEY constraint 'FK_dbo.Association_dbo.Item_ItemId' on table 'Association' may cause cycles or multiple cascade paths.
			modelBuilder.Entity<Association>().HasRequired(m => m.CatalogItem).WithMany().WillCascadeOnDelete(false);
			modelBuilder.Entity<CategoryItemRelation>().HasRequired(p => p.Category).WithMany().WillCascadeOnDelete(false);
			modelBuilder.Entity<ItemRelation>().HasRequired(m => m.ChildItem).WithMany().WillCascadeOnDelete(false);
			// cascade delete Item and Category when PropertySet is deleted. This should happen ONLY when catalog is being deleted.
			modelBuilder.Entity<Item>().HasRequired(m => m.PropertySet).WithMany().WillCascadeOnDelete(true);
			modelBuilder.Entity<Category>().HasOptional(m => m.PropertySet).WithMany().WillCascadeOnDelete(true);

			base.OnModelCreating(modelBuilder);
		}
Esempio n. 23
0
 protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
 {
     modelBuilder.Entity<Geocache>().Property(a => a.Latitude).HasPrecision(18, 9);
     modelBuilder.Entity<Geocache>().Property(a => a.Longitude).HasPrecision(18, 9);
 }
        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<UserClaims>().ToTable("UserClaims").HasRequired(u => u.User).WithMany(x => x.Claims).HasForeignKey(t => t.UserId).WillCascadeOnDelete(false);
            modelBuilder.Entity<UserLoginTable>().ToTable("UserLogins").HasRequired(u => u.User).WithMany(x => x.Login).HasForeignKey(t => t.UserId).WillCascadeOnDelete(false);

            /*modelBuilder.Entity<IdentityUser>().HasMany(t => t.Roles).WithMany(c => c.Users)
                                .Map(t => t.ToTable("UserRoles")
                                    .MapLeftKey("UserId")
                                    .MapRightKey("RoleId"));*/

            modelBuilder.Entity<UserRolesTable>().ToTable("UserRoles");
            modelBuilder.Entity<IdentityRole>().ToTable("Roles");
            modelBuilder.Entity<IdentityUser>().ToTable("users");
            base.OnModelCreating(modelBuilder);

            //modelBuilder.Entity<ORCHA.Domain.Model.User>().Ignore(p => p.UserName);
            //modelBuilder.Entity<Domain.Model.Product>().HasRequired(e => e.Category)
            //.WithMany(e => e.Products).HasForeignKey(c=>c.CategoryId);
        }
Esempio n. 25
0
        public void MapEntity(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Title>()
                .Property(t => t.Name).HasColumnName("Name").IsUnicode(false);
            modelBuilder.Entity<Title>()
                .Property(t => t.Searchname).HasColumnName("Searchname");
            modelBuilder.Entity<Title>()
                .Property(t => t.Bitrate).HasColumnName("Bitrate");
            modelBuilder.Entity<Title>()
                .Property(t => t.Bytes).HasColumnName("Bytes");
            modelBuilder.Entity<Title>()
                .Property(t => t.CreationDate).HasColumnName("CreationDate");
            modelBuilder.Entity<Title>()
                .Property(t => t.EditDate).HasColumnName("EditDate");
            modelBuilder.Entity<Title>()
                .Property(t => t.Filename).HasColumnName("Filename");
            modelBuilder.Entity<Title>()
                 .Property(t => t.IsCollection).HasColumnName("IsCollection");
            modelBuilder.Entity<Title>()
                .Property(t => t.DurationInSeconds).HasColumnName("Duration");
            modelBuilder.Entity<Title>()
                .Property(t => t.IsOrdered).HasColumnName("IsOrdered");
            modelBuilder.Entity<Title>()
                .Property(t => t.Length).HasColumnName("Length");
            modelBuilder.Entity<Title>()
                .Property(t => t.Path).HasColumnName("Path");
            modelBuilder.Entity<Title>()
                .Property(t => t.Track).HasColumnName("Track");
            modelBuilder.Entity<Title>()
                .Property(t => t.AlbumId).HasColumnName("Album_ID");
            modelBuilder.Entity<Title>()
                .Property(t => t.InterpretId).HasColumnName("Interpret_ID");
            modelBuilder.Entity<Title>()
                .Property(t => t.Genre).HasColumnName("Genre");
            modelBuilder.Entity<Title>()
                .Property(t => t.PublicationYear).HasColumnName("Year");
            modelBuilder.Entity<Title>()
                .Property(t => t.SampleRate).HasColumnName("SampleRate");
            modelBuilder.Entity<Title>()
                .Property(t => t.Channels).HasColumnName("Channels");


        }
Esempio n. 26
0
        protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Content>().Property(cp => cp.Id)
                .HasColumnName("ContentId");
            modelBuilder.Entity<Content>().HasKey(cp => cp.Id);
            modelBuilder.Entity<Content>().ToTable("dbo.Content");

            modelBuilder.Entity<Charity>().Property(c => c.Id)
                .HasColumnName("CharityId");
            modelBuilder.Entity<Charity>().HasKey(c => c.Id);
            modelBuilder.Entity<Charity>().ToTable("dbo.Charity");

            modelBuilder.Entity<Volunteer>().Property(v => v.Id)
                .HasColumnName("VolunteerId");
            modelBuilder.Entity<Volunteer>().Property(v => v.MembershipId)
                .HasColumnName("MembershipId");
            modelBuilder.Entity<Volunteer>().Property(v => v.HasCancelled)
                .HasColumnName("HasCancelled");
            modelBuilder.Entity<Volunteer>().HasKey(v => v.Id);
            modelBuilder.Entity<Volunteer>().ToTable("dbo.Volunteer");
            modelBuilder.Entity<Volunteer>().Ignore(v => v.JobRoles);
            modelBuilder.Entity<Volunteer>().Ignore(v => v.Technologies);

            modelBuilder.Entity<JobRole>().Property(j => j.Id).HasColumnName("JobRoleId");
            modelBuilder.Entity<JobRole>().HasKey(j => j.Id);
            modelBuilder.Entity<JobRole>().ToTable("dbo.JobRole");

            modelBuilder.Entity<VolunteerJobRole>().HasKey(v => new { v.JobRoleId, v.VolunteerId });
            modelBuilder.Entity<VolunteerJobRole>().ToTable("dbo.VolunteerJobRoles");

            modelBuilder.Entity<Technology>().Property(t => t.Id).HasColumnName("TechnologyId");
            modelBuilder.Entity<Technology>().HasKey(t => t.Id);
            modelBuilder.Entity<Technology>().ToTable("dbo.Technology");

            modelBuilder.Entity<VolunteerTechnology>().HasKey(vt => new { vt.TechnologyId, vt.VolunteerId });
            modelBuilder.Entity<VolunteerTechnology>().ToTable("dbo.VolunteerTechnologies");

            modelBuilder.Entity<Team>().Property(t => t.Id)
                .HasColumnName("TeamId");
            modelBuilder.Entity<Team>().Property(t => t.Name)
                .HasColumnName("TeamName");
            modelBuilder.Entity<Team>().HasKey(t => t.Id);
            modelBuilder.Entity<Team>().ToTable("dbo.Team");

            modelBuilder.Entity<Setting>().Property(s => s.Id).HasColumnName("SettingId");
            modelBuilder.Entity<Setting>().HasKey(s => s.Id);
            modelBuilder.Entity<Setting>().ToTable("dbo.Setting");

            modelBuilder.Entity<ExperienceLevel>().Property(e => e.Id).HasColumnName("ExperienceLevelId");
            modelBuilder.Entity<ExperienceLevel>().HasKey(s => s.Id);
            modelBuilder.Entity<ExperienceLevel>().ToTable("dbo.ExperienceLevel");

            modelBuilder.Entity<Document>().Property(e => e.DocumentId).HasColumnName("DocumentId");
            modelBuilder.Entity<Document>().HasKey(s => s.DocumentId);
            modelBuilder.Entity<Document>().ToTable("dbo.Documents");

            modelBuilder.Entity<NonTechVolunteer>().HasKey(v => v.Id);
            modelBuilder.Entity<NonTechVolunteer>().Property(v => v.Id)
                .HasColumnName("VolunteerId");
            modelBuilder.Entity<NonTechVolunteer>().Property(v => v.HasCancelled)
                .HasColumnName("HasCancelled");
            modelBuilder.Entity<NonTechVolunteer>().Ignore(v => v.AreasOfExpertise);
            modelBuilder.Entity<NonTechVolunteer>().ToTable("dbo.NonTechVolunteer");

            modelBuilder.Entity<NonTechVolunteerExpertise>().HasKey(v => new { v.ExpertiseId, v.VolunteerId });
            modelBuilder.Entity<NonTechVolunteerExpertise>().ToTable("dbo.NonTechVolunteerExpertise");

            modelBuilder.Entity<Expertise>().HasKey(v => v.Id);
            modelBuilder.Entity<Expertise>().Property(e => e.Id).HasColumnName("ExpertiseId");
            modelBuilder.Entity<Expertise>().ToTable("dbo.Expertise");

            modelBuilder.Entity<Sponsor>().HasKey(v => v.Id);
            modelBuilder.Entity<Sponsor>().Property(e => e.Id).HasColumnName("SponsorId");
            modelBuilder.Entity<Sponsor>().ToTable("dbo.Sponsor");

            base.OnModelCreating(modelBuilder);
        }
Esempio n. 27
0
        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

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

            #region Category
            modelBuilder.Entity<dataModel.Category>().ToTable("Category").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.Category>().HasOptional(x => x.ParentCategory).WithMany().HasForeignKey(x => x.ParentCategoryId).WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.Category>().HasRequired(x => x.Catalog).WithMany().HasForeignKey(x => x.CatalogId).WillCascadeOnDelete(true);
            #endregion

            #region Item
            modelBuilder.Entity<dataModel.Item>().ToTable("Item").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.Item>().HasRequired(m => m.Catalog).WithMany().HasForeignKey(x => x.CatalogId).WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.Item>().HasOptional(m => m.Category).WithMany().HasForeignKey(x => x.CategoryId).WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.Item>().HasOptional(m => m.Parent).WithMany(x => x.Childrens).HasForeignKey(x => x.ParentId).WillCascadeOnDelete(false);
            #endregion

            #region Property
            modelBuilder.Entity<dataModel.Property>().ToTable("Property").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.Property>().HasOptional(m => m.Catalog).WithMany(x => x.Properties).HasForeignKey(x => x.CatalogId).WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.Property>().HasOptional(m => m.Category).WithMany(x => x.Properties).HasForeignKey(x => x.CategoryId).WillCascadeOnDelete(false);

            #endregion

            #region PropertyDictionaryValue
            modelBuilder.Entity<dataModel.PropertyDictionaryValue>().ToTable("PropertyDictionaryValue").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.PropertyDictionaryValue>().HasRequired(m => m.Property).WithMany(x => x.DictionaryValues).HasForeignKey(x => x.PropertyId).WillCascadeOnDelete(true);
            #endregion

            #region PropertyAttribute
            modelBuilder.Entity<dataModel.PropertyAttribute>().ToTable("PropertyAttribute").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.PropertyAttribute>().HasRequired(m => m.Property).WithMany(x => x.PropertyAttributes).HasForeignKey(x => x.PropertyId).WillCascadeOnDelete(true);
            #endregion

            #region PropertyValue
            modelBuilder.Entity<dataModel.PropertyValue>().ToTable("PropertyValue").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.PropertyValue>().HasOptional(m => m.CatalogItem).WithMany(x => x.ItemPropertyValues).HasForeignKey(x => x.ItemId).WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.PropertyValue>().HasOptional(m => m.Category).WithMany(x => x.CategoryPropertyValues).HasForeignKey(x => x.CategoryId).WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.PropertyValue>().HasOptional(m => m.Catalog).WithMany(x => x.CatalogPropertyValues).HasForeignKey(x => x.CatalogId).WillCascadeOnDelete(false);
            #endregion

            #region ItemRelation
            modelBuilder.Entity<dataModel.ItemRelation>().ToTable("ItemRelation").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.ItemRelation>().HasRequired(m => m.ChildItem).WithMany().HasForeignKey(x => x.ChildItemId).WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.ItemRelation>().HasOptional(m => m.ParentItem).WithMany().HasForeignKey(x => x.ParentItemId).WillCascadeOnDelete(false);

            #endregion

            #region CatalogImage
            modelBuilder.Entity<dataModel.Image>().ToTable("CatalogImage").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.Image>().HasOptional(m => m.Category).WithMany(x => x.Images).HasForeignKey(x => x.CategoryId).WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.Image>().HasOptional(m => m.CatalogItem).WithMany(x => x.Images).HasForeignKey(x => x.ItemId).WillCascadeOnDelete(false);
            #endregion

            #region EditorialReview
            modelBuilder.Entity<dataModel.EditorialReview>().ToTable("EditorialReview").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.EditorialReview>().HasRequired(x => x.CatalogItem).WithMany(x => x.EditorialReviews).HasForeignKey(x => x.ItemId).WillCascadeOnDelete(true);
            #endregion

            #region AssociationGroup
            modelBuilder.Entity<dataModel.AssociationGroup>().ToTable("AssociationGroup").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.AssociationGroup>().HasRequired(x => x.CatalogItem).WithMany(x => x.AssociationGroups).HasForeignKey(x => x.ItemId).WillCascadeOnDelete(true);
            #endregion

            #region Association
            modelBuilder.Entity<dataModel.Association>().ToTable("Association").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.Association>().HasRequired(m => m.CatalogItem).WithMany(x => x.Assosiations).HasForeignKey(x => x.ItemId).WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.Association>().HasRequired(m => m.AssociationGroup).WithMany(x => x.Associations).HasForeignKey(x => x.AssociationGroupId).WillCascadeOnDelete(true);
            #endregion

            #region Asset
            modelBuilder.Entity<dataModel.Asset>().ToTable("CatalogAsset").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.Asset>().HasRequired(m => m.CatalogItem).WithMany(x => x.Assets).HasForeignKey(x => x.ItemId).WillCascadeOnDelete(true);
            #endregion

            #region CatalogLanguage
            modelBuilder.Entity<dataModel.CatalogLanguage>().ToTable("CatalogLanguage").HasKey(x => x.Id).Property(x => x.Id);
            modelBuilder.Entity<dataModel.CatalogLanguage>().HasRequired(m => m.Catalog).WithMany(x => x.CatalogLanguages).HasForeignKey(x => x.CatalogId).WillCascadeOnDelete(true);
            #endregion

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

            modelBuilder.Entity<dataModel.CategoryItemRelation>().HasOptional(p => p.Category).WithMany().HasForeignKey(x => x.CategoryId).WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.CategoryItemRelation>().HasRequired(p => p.CatalogItem).WithMany(x => x.CategoryLinks).HasForeignKey(x => x.ItemId).WillCascadeOnDelete(false);
            modelBuilder.Entity<dataModel.CategoryItemRelation>().HasRequired(p => p.Catalog).WithMany().HasForeignKey(x => x.CatalogId).WillCascadeOnDelete(false);
            #endregion

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

            modelBuilder.Entity<dataModel.CategoryRelation>().HasOptional(x => x.TargetCategory)
                                       .WithMany(x => x.IncommingLinks)
                                       .HasForeignKey(x => x.TargetCategoryId).WillCascadeOnDelete(false);

            modelBuilder.Entity<dataModel.CategoryRelation>().HasRequired(x => x.SourceCategory)
                                       .WithMany(x => x.OutgoingLinks)
                                       .HasForeignKey(x => x.SourceCategoryId).WillCascadeOnDelete(false);

            modelBuilder.Entity<dataModel.CategoryRelation>().HasOptional(x => x.TargetCatalog)
                                       .WithMany(x => x.IncommingLinks)
                                       .HasForeignKey(x => x.TargetCatalogId).WillCascadeOnDelete(false);
            #endregion
            base.OnModelCreating(modelBuilder);
        }
 /// <summary>
 /// Override
 /// </summary>
 /// <param name="modelBuilder"></param>
 protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
 {
     // Set precision of ExchangeRate.Rate field to 18 number with 6 number on the right side
     modelBuilder.Entity<ExchangeRate>().Property(obj => obj.Rate).HasPrecision(18, 6);
 }