private MappingConfiguration TeamMapping() { var mapping = new MappingConfiguration<Team>(); mapping.MapType() .ToTable("Team"); mapping.HasProperty(m => m.Id) .IsIdentity(KeyGenerator.Autoinc); mapping.HasProperty(m => m.IsOpen) .HasColumnType("bit"); mapping.HasAssociation(m => m.Owner) .IsManaged() .ToColumn("OwnerId"); mapping.HasAssociation(m => m.Things) .IsManaged() .ToColumn("TeamId"); mapping.HasAssociation(m => m.Members) .WithOpposite(t => t.Team) .IsManaged() .IsDependent() .ToColumn("TeamId"); return mapping; }
private MappingConfiguration<Question> CreateQuestionMapping() { MappingConfiguration<Question> questionMapping = new MappingConfiguration<Question>(); questionMapping.MapType(question => new { QuestionId = question.Id, QueryText = question.QueryText, PostedById = question.PostedById }) .ToTable("Questions"); questionMapping.HasProperty(q => q.Id).IsIdentity(); questionMapping.HasAssociation(q => q.PostedBy) .WithOpposite(u => u.CreatedQuestions) .HasConstraint((q, u) => q.PostedById == u.Id); questionMapping.HasAssociation(q => q.UsersThatVoted) .WithOpposite(u => u.VotedOnQuestions) .IsManaged() .MapJoinTable("QuestionsUsers", (q, u) => new { QuestionGuid = q.Id, UserGuid = u.Id }); questionMapping.HasAssociation(q => q.Answers) .WithOpposite(a => a.Question) .HasConstraint((q, a) => q.Id == a.QuestionId) .IsManaged(); return questionMapping; }
private void MapItem(IList<MappingConfiguration> mappings) { var itemMapping = new MappingConfiguration<ProductItem>(); itemMapping.HasProperty(p => p.Id).IsIdentity(); itemMapping.MapType(p => new { }).ToTable("custom_products"); itemMapping.HasProperty(p => p.Price); itemMapping.HasProperty(p => p.QuantityInStock); itemMapping.HasAssociation<Telerik.Sitefinity.Security.Model.Permission>(p => p.Permissions); itemMapping.HasProperty(p => p.InheritsPermissions); itemMapping.HasProperty(p => p.CanInheritPermissions); itemMapping.HasAssociation(p => p.Urls).WithOppositeMember("parent","Parent").ToColumn("content_id").IsDependent().IsManaged(); //map language data & published translations CommonFluentMapping.MapILifecycleDataItemFields<ProductItem>(itemMapping, this.Context); mappings.Add(itemMapping); }
public void PrepareDataAccessCountryAssociationConfigurations(MappingConfiguration<DataAccessCountry> configuration) { configuration.HasAssociation(x => x.DataAccessDealers) .HasFieldName("dataAccessDealers") .WithOpposite(x => x.DataAccessCountry) .ToColumn("CountryId") .HasConstraint((y, x) => x.CountryId == y.Id) .WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareDataAccessIncomeAssociationConfigurations(MappingConfiguration<DataAccessIncome> configuration) { configuration.HasAssociation(x => x.DataAccessDealer) .HasFieldName("dataAccessDealer") .WithOpposite(x => x.DataAccessIncomes) .ToColumn("DealerId") .HasConstraint((x, y) => x.DealerId == y.Id) .IsRequired() .WithDataAccessKind(DataAccessKind.ReadWrite); }
private void MapItem(IList<MappingConfiguration> mappings) { var itemMapping = new MappingConfiguration<AgentItem>(); itemMapping.HasProperty(p => p.Id).IsIdentity(); itemMapping.MapType(p => new { }).ToTable("sfex_agent_item"); itemMapping.HasProperty(p => p.Email); itemMapping.HasProperty(p => p.PhoneNumber); itemMapping.HasProperty(p => p.Address); itemMapping.HasProperty(p => p.PostalCode); itemMapping.HasAssociation<Telerik.Sitefinity.Security.Model.Permission>(p => p.Permissions); itemMapping.HasProperty(p => p.InheritsPermissions); itemMapping.HasAssociation<Telerik.Sitefinity.Security.Model.PermissionsInheritanceMap>(p => p.PermissionChildren); itemMapping.HasProperty(p => p.CanInheritPermissions); itemMapping.HasAssociation(p => p.Urls).WithOppositeMember("parent", "Parent").ToColumn("content_id").IsDependent().IsManaged(); CommonFluentMapping.MapILifecycleDataItemFields<AgentItem>(itemMapping, this.Context); mappings.Add(itemMapping); }
protected override IList<MappingConfiguration> PrepareMapping() { List<MappingConfiguration> mappingConfigurations = new List<MappingConfiguration>(); MappingConfiguration<Vendor> vendorConfiguration = new MappingConfiguration<Vendor>(); vendorConfiguration.MapType(v => new { VendorId = v.Id, VendorName = v.Name, }).ToTable("Vendors"); vendorConfiguration.HasProperty(v => v.Id).IsIdentity(); MappingConfiguration<Measure>measureConfiguration = new MappingConfiguration<Measure>(); measureConfiguration.MapType(m => new { MeasureId = m.Id, MeasureName = m.Name, }).ToTable("Measures"); measureConfiguration.HasProperty(m => m.Id).IsIdentity(); MappingConfiguration<Product> productConfiguration = new MappingConfiguration<Product>(); productConfiguration.MapType(p => new { ProductId = p.Id, ProductName = p.Name, VendorId=p.VendorId, MeasureId=p.MeasureId, BasePrice=p.BasePrice }).ToTable("Products"); productConfiguration.HasProperty(p => p.Id).IsIdentity(); productConfiguration.HasAssociation(p => p.Vendor).ToColumn("VendorId"); productConfiguration.HasAssociation(p => p.Measure).ToColumn("MeasureId"); mappingConfigurations.Add(productConfiguration); mappingConfigurations.Add(vendorConfiguration); mappingConfigurations.Add(measureConfiguration); return mappingConfigurations; }
private MappingConfiguration TeamUserMapping() { var mapping = new MappingConfiguration<TeamUser>(); mapping.MapType() .ToTable("TeamUser"); mapping.HasIdentity(map => new { map.UserId, map.TeamId, }); mapping.HasAssociation(m => m.Team) .WithOpposite(t => t.Members) .IsManaged() .IsDependent() .ToColumn("TeamId"); mapping.HasAssociation(m => m.User) .WithOpposite(t => t.Teams) .IsManaged() .IsDependent() .ToColumn("UserId"); mapping.HasProperty(m => m.Status) .HasColumnType("varchar") .HasPrecision(25) .WithConverter<EnumToStringConverter<TeamUserStatus>>(); mapping.HasProperty(m => m.Role) .HasColumnType("varchar") .HasPrecision(25) .WithConverter<EnumToStringConverter<TeamUserRole>>(); return mapping; }
/// <summary> /// Maps the ProjectItem class. /// </summary> /// <param name="mappings">The ProjectItem class mappings.</param> private void MapItem(IList<MappingConfiguration> mappings) { // initialize mapping var itemMapping = new MappingConfiguration<ProjectItem>(); itemMapping.HasProperty(p => p.Id).IsIdentity(); itemMapping.MapType(p => new { }).ToTable("sf_Projects"); // add properties itemMapping.HasProperty(p => p.Address); itemMapping.HasProperty(p => p.City); itemMapping.HasProperty(p => p.Region).IsNullable(); itemMapping.HasProperty(p => p.PostalCode); itemMapping.HasProperty(p => p.Country); // map urls table association itemMapping.HasAssociation(p => p.Urls).WithOppositeMember("parent", "Parent").ToColumn("content_id").IsDependent().IsManaged(); mappings.Add(itemMapping); }
private MappingConfiguration UserMapping() { var mapping = new MappingConfiguration<User>(); mapping.MapType() .ToTable("User"); mapping.HasProperty(m => m.Id) .IsIdentity(KeyGenerator.Autoinc); mapping.HasProperty(m => m.IsActive) .HasColumnType("bit"); mapping.HasAssociation(m => m.Things) .WithOpposite(m => m.AssignedToUser) .IsManaged() .ToColumn("AssignedToUserId"); mapping.HasAssociation(m => m.Teams) .WithOpposite(t => t.User) .IsManaged() .IsDependent() .ToColumn("UserId"); return mapping; }
protected override IList<MappingConfiguration> PrepareMapping() { List<MappingConfiguration> configuracionesMap = new List<MappingConfiguration>(); MappingConfiguration<Persona> PersonaConfiguration = new MappingConfiguration<Persona>(); PersonaConfiguration.MapType().ToTable("PERSONAS"); PersonaConfiguration.HasProperty(c => c.PersonaId).IsIdentity(KeyGenerator.Autoinc); PersonaConfiguration. HasAssociation(prop => prop.Propiedades).WithOpposite(pers => pers.Persona).HasConstraint((pers, prop) => pers.PersonaId == prop.PersonaId); PersonaConfiguration. HasAssociation(pers => pers.Contratos).WithOpposite(pers => pers.Persona).HasConstraint((pers, prop) => pers.PersonaId == prop.PersonaId); configuracionesMap.Add(PersonaConfiguration); MappingConfiguration<Propiedad> PropiedadesConfiguration = new MappingConfiguration<Propiedad>(); PropiedadesConfiguration.MapType().ToTable("PROPIEDADES"); PropiedadesConfiguration.HasProperty(c => c.PropiedadId).IsIdentity(KeyGenerator.Autoinc); PropiedadesConfiguration. HasAssociation(prop => prop.Comuna).WithOpposite(c => c.Propiedades).HasConstraint((prop, c) => prop.ComunaId == c.Id); PropiedadesConfiguration. HasAssociation(prop => prop.Region).WithOpposite(r => r.Propiedades).HasConstraint((prop, r) => prop.RegionId == r.RegionId); PropiedadesConfiguration. HasAssociation(prop => prop.ConjuntoHabitacional).WithOpposite(conHab => conHab.Propiedades).HasConstraint((p, conHab) => p.ConjuntoHabitacionalId == conHab.ConjuntoHabitacionalId); PropiedadesConfiguration. HasAssociation(prop => prop.ServiciosDeMantenciones).WithOpposite(sm => sm.Propiedad).HasConstraint((prop, sw) => prop.PropiedadId == sw.PropiedadId); PropiedadesConfiguration. HasAssociation(prop => prop.Contratos).WithOpposite(c => c.Propiedad).HasConstraint((prop, c) => prop.PropiedadId == c.PropiedadId); configuracionesMap.Add(PropiedadesConfiguration); MappingConfiguration<Contrato> ContratoConfiguration = new MappingConfiguration<Contrato>(); ContratoConfiguration.MapType().ToTable("CONTRATOS"); ContratoConfiguration.HasProperty(c => c.ContratoId).IsIdentity(KeyGenerator.Autoinc); ContratoConfiguration. HasAssociation(c => c.Pagos).WithOpposite(pago => pago.Contrato).HasConstraint((c, pago) => c.ContratoId == pago.ContratoId); ContratoConfiguration. HasAssociation(c => c.Documentos).WithOpposite(d => d.Contrato).HasConstraint((c, d) => c.ContratoId == d.ContratoId); configuracionesMap.Add(ContratoConfiguration); MappingConfiguration<Notaria> NotariaConfiguration = new MappingConfiguration<Notaria>(); NotariaConfiguration.MapType().ToTable("NOTARIAS"); NotariaConfiguration.HasProperty(n => n.NotariaId).IsIdentity(KeyGenerator.Autoinc); NotariaConfiguration. HasAssociation(n => n.Contratos).WithOpposite(c => c.Notaria).HasConstraint((n, c) => n.NotariaId == c.NotariaId); configuracionesMap.Add(NotariaConfiguration); MappingConfiguration<ConservadorBienRaiz> ConservadorBienRaizConfiguration = new MappingConfiguration<ConservadorBienRaiz>(); ConservadorBienRaizConfiguration.MapType().ToTable("CBRS"); ConservadorBienRaizConfiguration.HasProperty(cbr => cbr.ConservadorBienRaizId).IsIdentity(KeyGenerator.Autoinc); ConservadorBienRaizConfiguration. HasAssociation(cbr => cbr.Contratos).WithOpposite(c => c.ConservadorBienRaiz).HasConstraint((cbr, c) => cbr.ConservadorBienRaizId == c.ConservadorBienRaizId); configuracionesMap.Add(ConservadorBienRaizConfiguration); MappingConfiguration<Convenio> ConvenioConfiguration = new MappingConfiguration<Convenio>(); ConvenioConfiguration.MapType().ToTable("CONVENIOS"); ConvenioConfiguration.HasProperty(c => c.ConvenioId).IsIdentity(KeyGenerator.Autoinc); ConvenioConfiguration. HasAssociation(c => c.Contratos).WithOpposite(contrato => contrato.Convenio).HasConstraint((c, contrato) => c.ConvenioId == contrato.ConvenioId); configuracionesMap.Add(ConvenioConfiguration); MappingConfiguration<DocumentoDigital> DocumentoConfiguration = new MappingConfiguration<DocumentoDigital>(); DocumentoConfiguration.MapType().ToTable("DOCS_DIGITALES"); DocumentoConfiguration.HasProperty(c => c.DocumentoId).IsIdentity(KeyGenerator.Autoinc); DocumentoConfiguration. HasAssociation(dd => dd.TipoDocumentoDigital).WithOpposite(tdd => tdd.DocumentosDigitales).HasConstraint((dd, tdd) => dd.TipoDocumentoDigitalId == tdd.TipoDocumentoDigitalId); configuracionesMap.Add(DocumentoConfiguration); MappingConfiguration<TipoDocumentoDigital> TipoDocumentoDigitalConfiguration = new MappingConfiguration<TipoDocumentoDigital>(); TipoDocumentoDigitalConfiguration.MapType().ToTable("TIPOS_DOCS_D"); TipoDocumentoDigitalConfiguration.HasProperty(tdd => tdd.TipoDocumentoDigitalId).IsIdentity(KeyGenerator.Autoinc); configuracionesMap.Add(TipoDocumentoDigitalConfiguration); MappingConfiguration<ServicioMantencion> ServicioMantencionConfiguration = new MappingConfiguration<ServicioMantencion>(); ServicioMantencionConfiguration.MapType().ToTable("SERVICIOS_MANT"); ServicioMantencionConfiguration.HasProperty(c => c.ServicioMantencionId).IsIdentity(KeyGenerator.Autoinc); configuracionesMap.Add(ServicioMantencionConfiguration); MappingConfiguration<Pago> PagoConfiguration = new MappingConfiguration<Pago>(); PagoConfiguration.MapType().ToTable("PAGOS"); PagoConfiguration.HasProperty(c => c.PagoId).IsIdentity(KeyGenerator.Autoinc); configuracionesMap.Add(PagoConfiguration); MappingConfiguration<Banco> BancoConfiguration = new MappingConfiguration<Banco>(); BancoConfiguration.MapType().ToTable("BANCOS"); BancoConfiguration.HasProperty(c => c.BancoId).IsIdentity(KeyGenerator.Autoinc); BancoConfiguration. HasAssociation(c => c.Contratos).WithOpposite(contrato => contrato.Banco).HasConstraint((c, contrato) => c.BancoId == contrato.BancoId); configuracionesMap.Add(BancoConfiguration); MappingConfiguration<ConjuntoHabitacional> ConjuntoHabitacionalConfiguration = new MappingConfiguration<ConjuntoHabitacional>(); ConjuntoHabitacionalConfiguration.MapType().ToTable("CONJUNTOS_HAB"); ConjuntoHabitacionalConfiguration.HasProperty(c => c.ConjuntoHabitacionalId).IsIdentity(KeyGenerator.Autoinc); configuracionesMap.Add(ConjuntoHabitacionalConfiguration); MappingConfiguration<Region> RegionConfiguration = new MappingConfiguration<Region>(); RegionConfiguration.MapType().ToTable("REGIONES"); RegionConfiguration.HasProperty(c => c.RegionId).IsIdentity(KeyGenerator.Autoinc); configuracionesMap.Add(RegionConfiguration); MappingConfiguration<Comuna> ComunaConfiguration = new MappingConfiguration<Comuna>(); ComunaConfiguration.MapType().ToTable("COMUNAS"); ComunaConfiguration.HasProperty(c => c.Id).IsIdentity(KeyGenerator.Autoinc); configuracionesMap.Add(ComunaConfiguration); return configuracionesMap; }
public void PrepareCategoryAssociationConfigurations(MappingConfiguration<Category> configuration) { configuration.HasAssociation(x => x.Products).HasFieldName("_products").WithOpposite(x => x.Category).ToColumn("CategoryID").HasConstraint((y, x) => x.CategoryID == y.CategoryID ).WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareCustomerDemographicAssociationConfigurations(MappingConfiguration<CustomerDemographic> configuration) { configuration.HasAssociation(x => x.Customers).HasFieldName("_customers").WithOpposite(x => x.CustomerDemographics).WithDataAccessKind(DataAccessKind.ReadWrite).MapJoinTable("CustomerCustomerDemo", (x, y) => new{CustomerTypeID = x.CustomerTypeID, CustomerID = y.CustomerID}).CreatePrimaryKeyFromForeignKeys(); }
public void PrepareTerritoryAssociationConfigurations(MappingConfiguration<Territory> configuration) { configuration.HasAssociation(x => x.Region).HasFieldName("_region").WithOpposite(x => x.Territories).ToColumn("RegionID").HasConstraint((x, y) => x.RegionID == y.RegionID ).IsRequired().WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.Employees).HasFieldName("_employees").WithOpposite(x => x.Territories).WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareVRTicketTypeConfigurations(MappingConfiguration <VRTicketType> configuration) { configuration.HasProperty(x => x.ID).ToColumn(@"ID").IsIdentity(KeyGenerator.Autoinc).WithOpenAccessType(OpenAccessType.Int32).IsNotNullable(); configuration.HasProperty(x => x.Type).ToColumn(@"Type").WithOpenAccessType(OpenAccessType.Varchar).IsNotNullable().IsUnicode(); configuration.HasAssociation <VRTicket>(x => x.VRTickets).WithOpposite(op => op.VRTicketType).HasConstraint((x, y) => x.ID == y.VRTicketTypeID); }
private MappingConfiguration UserMapping() { var mapping = new MappingConfiguration<User>(); mapping.MapType() .ToTable("User"); mapping.HasProperty(m => m.Id) .IsIdentity(KeyGenerator.Autoinc); mapping.HasProperty(m => m.IsActive) .HasColumnType("bit"); mapping.HasAssociation(m => m.Things) .WithOpposite(m => m.AssignedToUser) .IsManaged() .ToColumn("AssignedToUserId"); mapping.HasAssociation(m => m.StarredThings) .MapJoinTable("UserStarredThings", (u, t) => new { UserId = u.Id, ThingId = t.Id }).CreatePrimaryKeyFromForeignKeys(); mapping.HasAssociation(m => m.Teams) .WithOpposite(t => t.User) .IsManaged() .IsDependent() .ToColumn("UserId"); return mapping; }
public void PrepareSupplierAssociationConfigurations(MappingConfiguration <Supplier> configuration) { configuration.HasAssociation(x => x.Products).HasFieldName("_products").WithOpposite(x => x.Supplier).ToColumn("SupplierID").HasConstraint((y, x) => x.SupplierID == y.SupplierID).WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareProductAssociationConfigurations(MappingConfiguration<Product> configuration) { configuration.HasAssociation(x => x.Category).HasFieldName("_category").WithOpposite(x => x.Products).ToColumn("CategoryID").HasConstraint((x, y) => x.CategoryID == y.CategoryID ).WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.Supplier).HasFieldName("_supplier").WithOpposite(x => x.Products).ToColumn("SupplierID").HasConstraint((x, y) => x.SupplierID == y.SupplierID ).WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.OrderDetails).HasFieldName("_orderDetails").WithOpposite(x => x.Product).ToColumn("ProductID").HasConstraint((y, x) => x.ProductID == y.ProductID ).WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareRegionAssociationConfigurations(MappingConfiguration<Region> configuration) { configuration.HasAssociation(x => x.Territories).HasFieldName("_territories").WithOpposite(x => x.Region).ToColumn("RegionID").HasConstraint((y, x) => x.RegionID == y.RegionID ).WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareShipperAssociationConfigurations(MappingConfiguration<Shipper> configuration) { configuration.HasAssociation(x => x.Orders).HasFieldName("_orders").WithOpposite(x => x.Shipper).ToColumn("ShipVia").HasConstraint((y, x) => x.ShipVia == y.ShipperID ).WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareSupplierAssociationConfigurations(MappingConfiguration<Supplier> configuration) { configuration.HasAssociation(x => x.Products).HasFieldName("_products").WithOpposite(x => x.Supplier).ToColumn("SupplierID").HasConstraint((y, x) => x.SupplierID == y.SupplierID ).WithDataAccessKind(DataAccessKind.ReadWrite); }
private MappingConfiguration ThingLogMapping() { var mapping = new MappingConfiguration<ThingLog>(); mapping.MapType() .ToTable("ThingLog"); mapping.HasProperty(m => m.Id) .IsIdentity(KeyGenerator.Autoinc); mapping.HasProperty(m => m.EditedByUserId) .ToColumn("EditedByUserId"); mapping.HasProperty(m => m.ThingId) .ToColumn("ThingId"); mapping.HasAssociation(m => m.Thing) .WithOpposite(m => m.History) .IsManaged() .IsDependent() .IsRequired() .ToColumn("ThingId"); mapping.HasAssociation(m => m.EditedBy) .WithOpposite(u => u.ThingLog) .IsManaged() .IsDependent() .IsRequired() .ToColumn("EditedByUserId"); mapping.HasProperty(m => m.Action) .HasColumnType("varchar") .HasPrecision(25) .WithConverter<EnumToStringConverter<ThingAction>>(); return mapping; }
protected override IList<MappingConfiguration> PrepareMapping() { var configurations = new List<MappingConfiguration>(); //config mapping var messageMapping = new MappingConfiguration<Message>(); messageMapping .MapType(message => new { ID = message.Id, message.Content, message.SenderId, message.RecipientId, message.Signature, message.InitVector, message.SessionKey, message.SentTime }).ToTable("Messages"); messageMapping .HasProperty(e => e.Id) .IsIdentity(KeyGenerator.Autoinc); var userMapping = new MappingConfiguration<User>(); userMapping .MapType(user => new { ID = user.Id, user.PasswordHash, user.PushToken, user.DeviceId, user.AllowPush }).ToTable("Users"); userMapping .HasProperty(e => e.Id) .IsIdentity(KeyGenerator.Autoinc); var sessionMapping = new MappingConfiguration<Session>(); sessionMapping .MapType(session => new { session.UserId, session.SessionKey, session.StarTime }).ToTable("Sessions"); var dateTimePropertyConfig = sessionMapping.HasProperty(s=> s.StarTime); dateTimePropertyConfig.IsCalculatedOn(DateTimeAutosetMode.InsertAndUpdate); var contactMapping = new MappingConfiguration<Contact>(); contactMapping .MapType(contact => new { ID = contact.Id, contact.Name, contact.PublicKey, contact.SenderId, contact.RecipientId }).ToTable("Contacts"); //set relations contactMapping .HasAssociation(e => e.Sender) .ToColumn("SenderId") .HasConstraint((m, u) => m.SenderId == u.Id); contactMapping .HasAssociation(e => e.Recipient) .ToColumn("RecipientId") .WithOpposite(u => u.ReceivedContacts) .HasConstraint((m, u) => m.RecipientId == u.Id); messageMapping .HasAssociation(e => e.Sender) .ToColumn("SenderId") .HasConstraint((m, u) => m.SenderId == u.Id); messageMapping .HasAssociation(e => e.Recipient) .ToColumn("RecipientId") .WithOpposite(u => u.ReceivedMessages) .HasConstraint((m, u) => m.RecipientId == u.Id); sessionMapping .HasAssociation(s => s.User) .ToColumn("UserId") .HasConstraint((m, u) => m.UserId == u.Id); //add configs configurations.Add(messageMapping); configurations.Add(userMapping); configurations.Add(sessionMapping); configurations.Add(contactMapping); return configurations; }
private MappingConfiguration ThingMapping() { var mapping = new MappingConfiguration<Thing>(); mapping.MapType() .ToTable("Thing"); mapping.HasProperty(m => m.Id) .IsIdentity(KeyGenerator.Autoinc); mapping.HasProperty(m => m.IsDeleted) .HasColumnType("bit"); //mapping.HasProperty(m => m.IsStarred) // .HasColumnType("bit"); mapping.HasAssociation(m => m.AssignedTo) .WithOpposite(t => t.Thing) .IsManaged() .IsDependent(); mapping.HasAssociation(m => m.History) .WithOpposite(tl => tl.Thing) .IsManaged() .IsDependent(); mapping.HasAssociation(m => m.Owner) .IsManaged() .ToColumn("OwnerId"); mapping.HasAssociation(m => m.Team) .WithOpposite(m => m.Things) .ToColumn("TeamId"); mapping.HasProperty(m => m.Status) .HasColumnType("varchar") .HasPrecision(25) .WithConverter<EnumToStringConverter<ThingStatus>>(); return mapping; }
public void PrepareHeaderAssociationConfigurations(MappingConfiguration <Header> configuration) { configuration.HasAssociation(x => x.Positions).WithOpposite(x => x.Header).HasConstraint((m, d) => d.HeaderId == m.Id).IsManaged().IsDependent(); }
private MappingConfiguration UserThingMapping() { var mapping = new MappingConfiguration<UserThing>(); mapping.MapType() .ToTable("UserThing"); mapping.HasIdentity(map => new { map.AssignedToUserId, map.ThingId }); mapping.HasAssociation(m => m.Thing) .IsManaged() .IsDependent() .ToColumn("ThingId"); mapping.HasAssociation(m => m.AssignedByUser) .ToColumn("AssignedByUserId"); mapping.HasAssociation(m => m.AssignedToUser) .WithOpposite(ut => ut.Things) .ToColumn("AssignedToUserId"); return mapping; }
public void PrepareCustomerAssociationConfigurations(MappingConfiguration<Customer> configuration) { configuration.HasAssociation(x => x.Orders).HasFieldName("_orders").WithOpposite(x => x.Customer).ToColumn("CustomerID").HasConstraint((y, x) => x.CustomerID == y.CustomerID ).WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.CustomerDemographics).HasFieldName("_customerDemographics").WithOpposite(x => x.Customers).WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareOrderAssociationConfigurations(MappingConfiguration<Order> configuration) { configuration.HasAssociation(x => x.Customer).HasFieldName("_customer").WithOpposite(x => x.Orders).ToColumn("CustomerID").HasConstraint((x, y) => x.CustomerID == y.CustomerID ).WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.Employee).HasFieldName("_employee").WithOpposite(x => x.Orders).ToColumn("EmployeeID").HasConstraint((x, y) => x.EmployeeID == y.EmployeeID ).WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.Shipper).HasFieldName("_shipper").WithOpposite(x => x.Orders).ToColumn("ShipVia").HasConstraint((x, y) => x.ShipVia == y.ShipperID ).WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.OrderDetails).HasFieldName("_orderDetails").WithOpposite(x => x.Order).ToColumn("OrderID").HasConstraint((y, x) => x.OrderID == y.OrderID ).WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareWorkHourAssociationConfigurations(MappingConfiguration<WorkHour> configuration) { configuration.HasAssociation(x => x.Employee).HasFieldName("_employee").WithOpposite(x => x.WorkHours).ToColumn("EmployeeId").HasConstraint((x, y) => x.EmployeeId == y.EmployeeID ).IsRequired().WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareOrderDetailAssociationConfigurations(MappingConfiguration<OrderDetail> configuration) { configuration.HasAssociation(x => x.Order).HasFieldName("_order").WithOpposite(x => x.OrderDetails).ToColumn("OrderID").HasConstraint((x, y) => x.OrderID == y.OrderID ).IsRequired().WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.Product).HasFieldName("_product").WithOpposite(x => x.OrderDetails).ToColumn("ProductID").HasConstraint((x, y) => x.ProductID == y.ProductID ).IsRequired().WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareGroupAssociationConfigurations(MappingConfiguration<Group> configuration) { configuration.HasAssociation(x => x.Users).HasFieldName("_users").WithOpposite(x => x.Group).ToColumn("GroupId").HasConstraint((y, x) => x.GroupId == y.GroupId ).WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareShipperAssociationConfigurations(MappingConfiguration <Shipper> configuration) { configuration.HasAssociation(x => x.Orders).HasFieldName("_orders").WithOpposite(x => x.Shipper).ToColumn("ShipVia").HasConstraint((y, x) => x.ShipVia == y.ShipperID).WithDataAccessKind(DataAccessKind.ReadWrite); }
public void PrepareEmployeeAssociationConfigurations(MappingConfiguration<Employee> configuration) { configuration.HasAssociation(x => x.WorkHours).HasFieldName("_workHours").WithOpposite(x => x.Employee).ToColumn("EmployeeId").HasConstraint((y, x) => x.EmployeeId == y.EmployeeID ).WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.Orders).HasFieldName("_orders").WithOpposite(x => x.Employee).ToColumn("EmployeeID").HasConstraint((y, x) => x.EmployeeID == y.EmployeeID ).WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.Employee1).HasFieldName("_employee1").WithOpposite(x => x.Employees).ToColumn("ReportsTo").HasConstraint((x, y) => x.ReportsTo == y.EmployeeID ).WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.Employees).HasFieldName("_employees").WithOpposite(x => x.Employee1).ToColumn("ReportsTo").HasConstraint((y, x) => x.ReportsTo == y.EmployeeID ).WithDataAccessKind(DataAccessKind.ReadWrite); configuration.HasAssociation(x => x.Territories).HasFieldName("_territories").WithOpposite(x => x.Employees).WithDataAccessKind(DataAccessKind.ReadWrite).MapJoinTable("EmployeeTerritories", (x, y) => new{EmployeeID = x.EmployeeID, TerritoryID = y.TerritoryID}).CreatePrimaryKeyFromForeignKeys(); }
private MappingConfiguration<Group> PrepareGroupMappingConfig() { MappingConfiguration<Group> groupMappingConfig = new MappingConfiguration<Group>(); groupMappingConfig.MapType().ToTable("Groups"); //backend independent property mapping groupMappingConfig.HasProperty(grp => grp.GroupId).IsIdentity().WithOpenAccessType(OpenAccessType.Int32).ToColumn("GroupId"); groupMappingConfig.HasProperty(grp => grp.Name).WithOpenAccessType(OpenAccessType.StringInfiniteLength).ToColumn("Name"); groupMappingConfig.HasProperty(grp => grp.Description).WithOpenAccessType(OpenAccessType.StringInfiniteLength).ToColumn("Description"); groupMappingConfig.HasAssociation(grp => grp.UsersInGroup) .WithOpposite(usr => usr.Group) .HasConstraint((grp, usr) => grp.GroupId == usr.GroupId) .IsManaged(); return groupMappingConfig; }
public void PreparePositionAssociationConfigurations(MappingConfiguration <Position> configuration) { configuration.HasAssociation(x => x.Header).WithOpposite(x => x.Positions).HasConstraint((d, m) => d.HeaderId == m.Id).IsManaged(); }