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