public DonationBuilder(EntityTypeConfiguration <Donation> entity)
{
entity.Property(d => d.Owner).IsRequired().HasMaxLength(200);
entity.Property(d => d.UpdatedBy).HasMaxLength(4000);
entity.HasRequired(r => r.Region).WithMany(d => d.Donations).HasForeignKey(r => r.RegionId);
entity.HasRequired(t => t.TreeType).WithMany(d => d.Donations).HasForeignKey(t => t.TreeTypeId);
}
public DonationBuilder(EntityTypeConfiguration <Donation> entity)
{
entity.Property(p => p.Owner).IsRequired().HasMaxLength(200);
entity.HasRequired(p => p.TreeType).WithMany(m => m.Donations).HasForeignKey(p => p.TreeTypeId);
entity.HasRequired(p => p.Region).WithMany(m => m.Donations).HasForeignKey(p => p.RegionId);
entity.Property(p => p.TreeName).IsRequired().HasMaxLength(200);
}
public void Configurar(EntityTypeConfiguration <Funcionario> entityConfiguration)
{
entityConfiguration
.ToTable("DadosFuncionario")
.HasKey(entity => entity.Id);
entityConfiguration
.Property(entity => entity.Nome).IsRequired().HasMaxLength(Funcionario.TamanhoMaximoNome);
entityConfiguration
.Property(entity => entity.Rg).IsRequired().HasMaxLength(Funcionario.TamanhoMaximoRg);
entityConfiguration
.Property(entity => entity.OrgaoEmissor).IsRequired().HasMaxLength(Funcionario.TamanhoMaximoOrgaoEmissor);
entityConfiguration
.Property(entity => entity.Sexo).IsRequired().HasMaxLength(Funcionario.TamanhMaximoSexo);
entityConfiguration
.Property(entity => entity.Cpf).IsRequired();
entityConfiguration
.Property(entity => entity.Telefone).IsRequired();
entityConfiguration
.Property(entity => entity.Ctps).IsRequired().HasMaxLength(Funcionario.TamanhoMaximoCtps);
entityConfiguration
.Property(entity => entity.Documento).IsRequired().HasMaxLength(Funcionario.TamanhoMaximoDocumento);
entityConfiguration
.Property(entity => entity.DataNascimento).IsRequired();
entityConfiguration
.HasRequired(entity => entity.Funcao)
.WithRequiredPrincipal();
entityConfiguration
.HasRequired(entity => entity.Endereco)
.WithRequiredPrincipal();
}
public void Configure(DbModelBuilder modelBuilder)
{
EntityTypeConfiguration <Projection> projectionModel = modelBuilder.Entity <Projection>();
projectionModel.HasKey(model => model.Id);
projectionModel.Property(model => model.MovieId).IsRequired();
projectionModel.Property(model => model.RoomId).IsRequired();
projectionModel.Property(model => model.StartDate).IsRequired();
projectionModel
.HasMany(r => r.Reservations)
.WithRequired();
projectionModel
.HasMany(t => t.Tickets)
.WithRequired();
projectionModel
.HasRequired(m => m.Movie)
.WithMany(p => p.Projections)
.HasForeignKey(x => x.MovieId);
projectionModel
.HasRequired(r => r.Room)
.WithMany(p => p.Projections)
.HasForeignKey(x => x.RoomId);
}
public static void Map(DbModelBuilder modelBuilder)
{
EntityTypeConfiguration <Trainer> trainerConfig = modelBuilder.Entity <Trainer>();
trainerConfig.HasKey(x => x.Id);
trainerConfig.Property(x => x.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);
trainerConfig.Property(x => x.FirstName).IsRequired().HasMaxLength(50).HasColumnType("varchar");
trainerConfig.Property(x => x.LastName).IsRequired().HasMaxLength(50).HasColumnType("varchar");
trainerConfig.Property(x => x.IsOnline).IsRequired().HasColumnType("bit");
trainerConfig.Property(x => x.Status).IsRequired().HasColumnType("bit");
trainerConfig.Property(x => x.DateOfBirth).IsOptional().HasColumnType("date");
trainerConfig.Property(x => x.DateOfRegistration).IsRequired().HasColumnType("date");
trainerConfig.HasRequired(t => t.Branch).WithMany(t => t.Trainers)
.HasForeignKey(t => t.BranchID)
.WillCascadeOnDelete(false);
trainerConfig.HasRequired(t => t.Gender).WithMany(t => t.Trainers)
.HasForeignKey(t => t.GenderID)
.WillCascadeOnDelete(false);
trainerConfig.HasRequired(t => t.Title).WithMany(t => t.Trainers)
.HasForeignKey(t => t.TitleID)
.WillCascadeOnDelete(false);
//Login deki userId burdaki Id olacak
}
public QualityPlanBuilder(EntityTypeConfiguration <QualityPlan> builder)
{
builder.Property(b => b.Description).HasMaxLength(4000);
builder.HasRequired(a => a.Company).WithMany(b => b.QualityPlans).HasForeignKey(a => a.CompanyId);
builder.HasOptional(a => a.Facility).WithMany(b => b.QualityPlans).HasForeignKey(a => a.FacilityId);
builder.HasRequired(a => a.Material).WithMany(b => b.QualityPlans).HasForeignKey(a => a.MaterialId);
}
void ConfigureCatalogItem(EntityTypeConfiguration <CatalogItem> builder)
{
builder.ToTable("Catalog");
builder.HasKey(ci => ci.Id);
builder.Property(ci => ci.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.None)
.IsRequired();
builder.Property(ci => ci.Name)
.IsRequired()
.HasMaxLength(50);
builder.Property(ci => ci.Price)
.IsRequired();
builder.Property(ci => ci.PictureFileName)
.IsRequired();
builder.Ignore(ci => ci.PictureUri);
builder.HasRequired <CatalogBrand>(ci => ci.CatalogBrand)
.WithMany()
.HasForeignKey(ci => ci.CatalogBrandId);
builder.HasRequired <CatalogType>(ci => ci.CatalogType)
.WithMany()
.HasForeignKey(ci => ci.CatalogTypeId);
}
public StockBuilder(EntityTypeConfiguration <Stock> builder)
{
builder.HasKey(s => s.Id);
builder.HasRequired(s => s.Personel).WithMany(a => a.Stocks).HasForeignKey(s => s.PersonelId);
builder.HasRequired(a => a.Product).WithMany(a => a.Stocks).HasForeignKey(s => s.ProductId);
builder.Property(a => a.StockEntryDate).IsRequired();
builder.Property(a => a.Quantity).IsRequired();
}
public MaterialInputBuilder(EntityTypeConfiguration <MaterialInput> builder)
{
builder.HasOptional(a => a.Order).WithMany(b => b.MaterialInputs).HasForeignKey(a => a.OrderId);
builder.HasOptional(a => a.OrderType).WithMany(b => b.MaterialInputs).HasForeignKey(a => a.OrderTypeId);
builder.HasRequired(a => a.Material).WithMany(b => b.MaterialInputs).HasForeignKey(a => a.MaterialId);
builder.HasRequired(a => a.Supplier).WithMany(b => b.MaterialInputs).HasForeignKey(a => a.SupplierId);
builder.HasRequired(a => a.StockLocation).WithMany(b => b.MaterialInputs).HasForeignKey(a => a.StockLocationId);
}
public PlantingBuilder(EntityTypeConfiguration <Planting> entity)
{
entity.Property(p => p.Lat).IsRequired().HasMaxLength(200);
entity.Property(p => p.Long).IsRequired().HasMaxLength(200);
entity.Property(p => p.PlantingCode).IsRequired().HasMaxLength(200);
entity.HasRequired(p => p.PlanterUser).WithMany(m => m.Plantings).HasForeignKey(p => p.PlanterUserId);
entity.HasRequired(p => p.Donation).WithMany(m => m.Plantings).HasForeignKey(p => p.DonationId);
}
public OrderBuilder(EntityTypeConfiguration <Order> builder)
{
builder.HasRequired(a => a.Customer).WithMany(b => b.Orders).HasForeignKey(a => a.CustomerId);
builder.Property(b => b.Created).HasMaxLength(100);
builder.HasRequired(a => a.Product).WithMany(b => b.Orders).HasForeignKey(a => a.ProductId
);
builder.Property(b => b.Description).HasMaxLength(4000);
builder.HasOptional(a => a.Tax).WithMany(b => b.Orders).HasForeignKey(a => a.TaxId);
}
public static void Map(DbModelBuilder modelBuilder)
{
EntityTypeConfiguration <MessageGroup_User> messageGroupUserConfig = modelBuilder.Entity <MessageGroup_User>();
messageGroupUserConfig.HasKey(mgu => mgu.Id);
messageGroupUserConfig.HasRequired(mgu => mgu.User).WithMany(mgu => mgu.MessageGroupUsers).HasForeignKey(mgu => mgu.UserID).WillCascadeOnDelete(false);
messageGroupUserConfig.HasRequired(mgu => mgu.MessageGroup).WithMany(mgu => mgu.MessageGroupUsers).HasForeignKey(mgu => mgu.MessageGroupID).WillCascadeOnDelete(false);
}
public static EntityTypeConfiguration <ProductParameterValue> Map()
{
var map = new EntityTypeConfiguration <ProductParameterValue>();
map.HasRequired(P => P.Product).WithMany(p => p.ProductParameterValues).HasForeignKey(p => p.ProductId).WillCascadeOnDelete(false);
map.HasRequired(P => P.ProductParameter).WithMany(p => p.ProductParameterValues).HasForeignKey(p => p.ProductParameterId).WillCascadeOnDelete(false);
map.HasKey(P => new { P.ProductId, P.ProductParameterId });
return(map);
}
public static EntityTypeConfiguration <InventoryOutsDeatil> Map()
{
var map = new EntityTypeConfiguration <InventoryOutsDeatil>();
map.HasKey(P => new { P.ProductId, P.InventoryOutsHeaderId });
map.HasRequired(I => I.inventoryOutsHeader).WithMany(C => C.InventoryOutsDeatiles).HasForeignKey(p => p.InventoryOutsHeaderId);
map.HasRequired(I => I.prodocut).WithMany(C => C.InventoryOutsDeatils).HasForeignKey(p => p.ProductId);
return(map);
}
internal static void OnModelCreating(EntityTypeConfiguration <ModuleFunction> entityTypeConfiguration)
{
entityTypeConfiguration.HasRequired(i => i.Module)
.WithMany(i => i.ModuleFunctions)
.HasForeignKey(i => i.ModuleID);
entityTypeConfiguration.HasRequired(i => i.Function)
.WithMany(i => i.ModuleFunctions)
.HasForeignKey(i => i.FunctionID);
}
public SaleBuilder(EntityTypeConfiguration <Sale> builder)
{
builder.HasKey(s => s.Id);
builder.HasRequired(s => s.Product).WithMany(a => a.Sales).HasForeignKey(s => s.ProductId);
builder.HasRequired(s => s.Stock).WithMany(a => a.Sales).HasForeignKey(s => s.StockId);
builder.HasRequired(s => s.Customer).WithMany(c => c.Purchases).HasForeignKey(s => s.CustomerId);
builder.Property(s => s.Amount).HasPrecision(18, 2).IsRequired();
builder.HasRequired(s => s.Shipment).WithMany(a => a.Sales).HasForeignKey(s => s.ShipmentId);
builder.Property(s => s.SellingDate).IsRequired();
}
public OrderBuilder(EntityTypeConfiguration <Order> builder)
{
builder.Property(b => b.Name).HasMaxLength(100).IsRequired();
builder.HasOptional(a => a.Company).WithMany(b => b.Orders).HasForeignKey(a => a.CompanyId);
builder.HasOptional(a => a.Facility).WithMany(b => b.Orders).HasForeignKey(a => a.FacilityId);
builder.HasRequired(a => a.BusinessArea).WithMany(b => b.Orders).HasForeignKey(a => a.BusinessAreaId);
builder.HasRequired(a => a.PurchasingDepartment).WithMany(b => b.Orders).HasForeignKey(a => a.PurchasingDepartmentId);
builder.HasRequired(a => a.OrderType).WithMany(b => b.Orders).HasForeignKey(a => a.OrderTypeId);
builder.HasRequired(a => a.Supplier).WithMany(b => b.Orders).HasForeignKey(a => a.SupplierId);
}
public CompanyBuilder(EntityTypeConfiguration <Company> builder)
{
builder.Property(b => b.Name).HasMaxLength(100).IsRequired();
builder.Property(b => b.Phone).HasMaxLength(20);
builder.Property(b => b.Address).HasMaxLength(500);
builder.HasRequired(a => a.Country).WithMany(b => b.Companies).HasForeignKey(a => a.CountryId);
builder.HasRequired(a => a.City).WithMany(b => b.Companies).HasForeignKey(a => a.CityId);
builder.HasOptional(a => a.Region).WithMany(b => b.Companies).HasForeignKey(a => a.RegionId);
}
public static void Map(DbModelBuilder modelBuilder)
{
EntityTypeConfiguration <HomeworkDelivery> hWDeliveryConfig = modelBuilder.Entity <HomeworkDelivery>();
hWDeliveryConfig.HasKey(hwd => hwd.Id);
hWDeliveryConfig.Property(hwd => hwd.DateOfDelivery).IsRequired().HasColumnType("date");
hWDeliveryConfig.HasRequired(hwd => hwd.Homework).WithMany(hwd => hwd.HomeworkDeliverys).HasForeignKey(hwd => hwd.HomeworkID).WillCascadeOnDelete(false);
hWDeliveryConfig.HasRequired(hwd => hwd.Student).WithMany(hwd => hwd.HomeworkDeliverys).HasForeignKey(hwd => hwd.StudentID).WillCascadeOnDelete(false);
}
public InvoiceBuilder(EntityTypeConfiguration <Invoice> builder)
{
builder.HasRequired(a => a.Customer).WithMany(b => b.Invoices).HasForeignKey(a => a.CustomerId);
builder.Property(b => b.Address).HasMaxLength(4000);
builder.Property(b => b.InvoiceAddress).HasMaxLength(4000);
builder.Property(b => b.Created).HasMaxLength(100);
builder.Property(b => b.MobilePhone).HasMaxLength(20).IsRequired();
builder.HasRequired(a => a.Product).WithMany(b => b.Invoices).HasForeignKey(a => a.ProductId);
builder.Property(b => b.Description).HasMaxLength(4000);
builder.HasOptional(a => a.Tax).WithMany(b => b.Invoices).HasForeignKey(a => a.TaxId);
}
private void MapProduct(EntityTypeConfiguration <Product> product)
{
product.HasKey(i => i.Id).ToTable("Products");
product.Property(i => i.Id).HasColumnName("ID").HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
product.Property(i => i.ProductTypeId).HasColumnName("FKProductTypeID").IsRequired();
product.HasRequired(i => i.ProductType).WithMany().HasForeignKey(i => i.ProductTypeId);
product.Property(i => i.SalesResponsibleId).HasColumnName("SalesResponsibleID").IsRequired();
product.HasRequired(i => i.SalesResponsible).WithMany().HasForeignKey(i => i.SalesResponsibleId);
product.Property(i => i.PlaceId).HasColumnName("FKPlaceID").IsRequired();
product.HasRequired(i => i.Place).WithMany().HasForeignKey(i => i.PlaceId);
product.Property(i => i.Description).IsRequired();
product.Property(i => i.LivingSpace).IsOptional();
product.Property(i => i.PlotSize).IsOptional();
product.Property(i => i.NumberOfRooms).IsOptional();
product.Property(i => i.Price).IsOptional();
product.Property(i => i.MonthlyCharge).IsOptional();
product.Property(i => i.SquareMeterPrice).IsOptional();
product.Property(i => i.YearBuilt).IsOptional();
product.Property(i => i.ExternalLink).IsRequired();
product.Property(i => i.ExternalPicLink).IsOptional();
product.Property(i => i.InsertDate).IsRequired();
product.Property(i => i.Address).IsRequired();
product.Property(i => i.Lat).IsOptional();
product.Property(i => i.Long).IsOptional();
product.Property(i => i.IsApproved).IsRequired();
product.Property(i => i.RefNr).IsOptional();
product.Property(i => i.ThumbnailUrl).IsOptional();
product.Property(i => i.PriceFilter).IsOptional();
}
public static void Map(DbModelBuilder modelBuilder)
{
EntityTypeConfiguration <Message> messageConfig = modelBuilder.Entity <Message>();
messageConfig.HasKey(m => m.Id);
messageConfig.Property(m => m.Content).IsRequired().HasColumnType("varchar").HasMaxLength(2000);
messageConfig.Property(m => m.DateOfSend).IsRequired().HasColumnType("date");
messageConfig.HasRequired(m => m.User).WithMany(m => m.Messages).HasForeignKey(m => m.UserID).WillCascadeOnDelete(false);
messageConfig.HasRequired(m => m.MessageGroup).WithMany(m => m.Messages).HasForeignKey(m => m.MessageGroupID).WillCascadeOnDelete(false);
}
public static EntityTypeConfiguration <ProductCategory> Map()
{
var map = new EntityTypeConfiguration <ProductCategory>();
map.Property(P => P.Title).HasMaxLength(100).IsRequired();
map.Property(P => P.Description).HasMaxLength(1000);
map.HasRequired(P => P.Inventories).WithMany(C => C.ProductCategories).HasForeignKey(p => p.InventoryId).WillCascadeOnDelete(false);
map.HasOptional(C => C.DeletedUser).WithMany(U => U.DeletedProductCategory).HasForeignKey(I => I.DeletedByUserId);
map.HasRequired(C => C.CreatedUser).WithMany(U => U.CreatedProductCategory).HasForeignKey(I => I.CreatedByUserId).WillCascadeOnDelete(false);
map.HasOptional(C => C.ChangedUser).WithMany(U => U.ChangedProductCategory).HasForeignKey(I => I.ChangedByUserId);
return(map);
}
public static void Map(DbModelBuilder modelBuilder)
{
EntityTypeConfiguration <Comment> commentConfig = modelBuilder.Entity <Comment>();
commentConfig.HasKey(x => x.Id);
commentConfig.Property(x => x.DateOfComment).IsRequired().HasColumnType("datetime");
commentConfig.Property(x => x.Description).IsRequired().HasColumnType("nvarchar").HasMaxLength(200);
commentConfig.HasRequired(x => x.Topic).WithMany(x => x.Comments).HasForeignKey(x => x.TopicID);
commentConfig.HasRequired(x => x.Login).WithMany(x => x.Comments).HasForeignKey(x => x.UserID);
}
public static void Map(DbModelBuilder modelBuilder)
{
EntityTypeConfiguration <Answer> answerConfig = modelBuilder.Entity <Answer>();
answerConfig.HasKey(x => new { x.QuestionID, x.StudentID });
answerConfig.HasRequired(x => x.Question).WithMany(x => x.Answers).HasForeignKey(x =>
x.QuestionID)
.WillCascadeOnDelete(false);
answerConfig.HasRequired(x => x.Student).WithMany(x => x.Answers).HasForeignKey(x => x.StudentID).WillCascadeOnDelete(false);
answerConfig.HasRequired(x => x.Option).WithMany(x => x.Answers).HasForeignKey(x => x.OptionID).WillCascadeOnDelete(false);
}
internal static void Define(EntityTypeConfiguration<Domain.ItemInstance> config)
{
config.HasRequired(r => r.Item)
.WithMany(r => r.OwnedBy)
.HasForeignKey(fk => fk.ItemId)
.WillCascadeOnDelete(false);
config.HasRequired(r => r.Owner)
.WithMany(r => r.Items)
.HasForeignKey(fk => fk.OwnerId)
.WillCascadeOnDelete(false);
}
public static EntityTypeConfiguration <InventoryInsHeader> Map()
{
var map = new EntityTypeConfiguration <InventoryInsHeader>();
map.HasRequired(I => I.Inv).WithMany(C => C.InventoryInsHeaders).HasForeignKey(p => p.InventoryId);
map.HasRequired(I => I.type).WithMany(C => C.InventoryInsHeaders).HasForeignKey(p => p.TypeId);
map.HasOptional(C => C.DeletedUser).WithMany(U => U.DeletedInventoryInsHeader).HasForeignKey(I => I.AcceptedByUserId);
map.HasOptional(C => C.DeletedUser).WithMany(U => U.DeletedInventoryInsHeader).HasForeignKey(I => I.DeletedByUserId);
map.HasRequired(C => C.CreatedUser).WithMany(U => U.CreatedInventoryInsHeader).HasForeignKey(I => I.CreatedByUserId).WillCascadeOnDelete(false);
map.HasOptional(C => C.ChangedUser).WithMany(U => U.ChangedInventoryInsHeader).HasForeignKey(I => I.ChangedByUserId);
return(map);
}
protected void buildProductDocs(EntityTypeConfiguration <ProductDoc> productDocEntity)
{
productDocEntity
.HasKey(x => new { x.blobID, x.productID });
productDocEntity
.HasRequired(x => x.product)
.WithMany(x => x.files)
.HasForeignKey(x => x.productID);
productDocEntity
.HasRequired(x => x.blob);
}
public static EntityTypeConfiguration <Inventory> Map()
{
var map = new EntityTypeConfiguration <Inventory>();
map.Property(I => I.Title).HasMaxLength(100).IsRequired();
map.Property(I => I.Description).HasMaxLength(1000);
map.Property(I => I.Address).HasMaxLength(1000);
map.HasRequired(I => I.corporation).WithMany(C => C.Inventories).HasForeignKey(c => c.CorporationId);
map.HasOptional(C => C.DeletedUser).WithMany(U => U.DeletedInventory).HasForeignKey(I => I.DeletedByUserId);
map.HasRequired(C => C.CreatedUser).WithMany(U => U.CreatedInventory).HasForeignKey(I => I.CreatedByUserId).WillCascadeOnDelete(false);
map.HasOptional(C => C.ChangedUser).WithMany(U => U.ChangedInventory).HasForeignKey(I => I.ChangedByUserId);
return(map);
}
public SystemUserBuilder(EntityTypeConfiguration <SystemUser> builder)
{
builder.Property(b => b.UserName).HasMaxLength(100).IsRequired();
builder.Property(b => b.ContactNumber).HasMaxLength(15);
builder.Property(b => b.Name).HasMaxLength(100).IsRequired();
builder.Property(b => b.Surname).HasMaxLength(100).IsRequired();
builder.Property(b => b.Email).HasMaxLength(100);
builder.Property(b => b.Profile).HasMaxLength(500);
builder.Property(b => b.FilePath).HasMaxLength(500);
builder.HasRequired(a => a.Company).WithMany(b => b.SystemUsers).HasForeignKey(a => a.CompanyId);
builder.HasRequired(a => a.Department).WithMany(b => b.SystemUsers).HasForeignKey(a => a.DepartmentId);
builder.HasOptional(a => a.Position).WithMany(b => b.SystemUsers).HasForeignKey(a => a.PositionId);
}
public static void Map(DbModelBuilder modelBuilder)
{
EntityTypeConfiguration <Login> loginConfig = modelBuilder.Entity <Login>();
loginConfig.HasKey(x => x.Id);
loginConfig.Property(x => x.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);
loginConfig.Property(x => x.UserName).IsRequired().HasColumnType("nvarchar").HasMaxLength(50);
loginConfig.Property(x => x.Mail).IsRequired().HasColumnType("nvarchar").HasMaxLength(50);
loginConfig.Property(x => x.Password).IsRequired().HasColumnType("nvarchar").HasMaxLength(36);
loginConfig.Property(x => x.CitizenNumber).IsRequired().HasColumnType("char").HasMaxLength(11);
loginConfig.HasRequired(x => x.Student).WithRequiredPrincipal(x => x.Login);
loginConfig.HasRequired(x => x.Trainer).WithRequiredPrincipal(x => x.Login);
}
protected void buildOrders(EntityTypeConfiguration<Order> orderEntity)
{
orderEntity
.HasKey(x => x.orderID)
.Property(x => x.orderDate)
.IsRequired();
orderEntity
.Property(x => x.status)
.IsRequired();
orderEntity
.Property(x => x.address)
.IsRequired()
.HasMaxLength(400);
orderEntity
.Property(x => x.timeStamp)
.IsRequired();
orderEntity
.HasRequired(x => x.customer)
.WithMany(x => x.orders);
orderEntity
.HasMany(x => x.products)
.WithRequired(x => x.order)
.WillCascadeOnDelete();
}
protected void buildProductDocs(EntityTypeConfiguration<ProductDoc> productDocEntity)
{
productDocEntity
.HasKey(x => new { x.blobID, x.productID });
productDocEntity
.HasRequired(x => x.product)
.WithMany(x => x.files)
.HasForeignKey(x => x.productID);
productDocEntity
.HasRequired(x => x.blob);
}
protected void buildOrderItems(EntityTypeConfiguration<OrderItem> orderItemEntity)
{
orderItemEntity
.HasKey(x => new { x.productID, x.orderID });
orderItemEntity
.HasRequired(x => x.order)
.WithMany(x => x.products)
.HasForeignKey(x => x.orderID);
orderItemEntity
.Property(x => x.quantity)
.IsRequired();
}
