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.HasAssociation(m => m.AssignedTo)
.WithOpposite(t => t.Thing)
.IsManaged()
.IsDependent();
mapping.HasAssociation(m => m.Owner)
.IsManaged()
.ToColumn("OwnerId");
mapping.HasAssociation(m => m.Team)
.WithOpposite(m => m.TeamThings)
.ToColumn("TeamId");
mapping.HasProperty(m => m.Status)
.HasColumnType("varchar")
.HasPrecision(25)
.WithConverter <EnumToStringConverter <ThingStatus> >();
return(mapping);
}
public MappingConfiguration <VRWaiverLog> GetVRWaiverLogClassConfiguration()
{
MappingConfiguration <VRWaiverLog> configuration = new MappingConfiguration <VRWaiverLog>();
configuration.MapType(x => new { }).ToTable("VRWaiverLogs");
return(configuration);
}
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.TeamThings)
.IsManaged()
.ToColumn("TeamId");
mapping.HasAssociation(m => m.TeamMembers)
.WithOpposite(t => t.Team)
.IsManaged()
.IsDependent()
.ToColumn("TeamId");
return(mapping);
}
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);
}
protected override IList <MappingConfiguration> PrepareMapping()
{
List <MappingConfiguration> configurations = new List <MappingConfiguration>();
MappingConfiguration <Report> reportConfiguration = new MappingConfiguration <Report>();
reportConfiguration.MapType(x => new
{
ID = x.Id,
Name = x.Name,
Duration = x.Duration,
Destination = x.Destination,
ClientsCount = x.ClientsCount,
TotalIncome = x.TotalIncome,
TransportCompany = x.TransportCompany,
TransportType = x.TransportType,
GuideName = x.GuideName,
ExpenseId = x.ExpenseId
}).ToTable("Reports");
reportConfiguration.HasProperty(p => p.Id).IsIdentity(KeyGenerator.Autoinc);
configurations.Add(reportConfiguration);
return(configurations);
}
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);
}
/// <summary>
/// Maps the AmpPages items.
/// </summary>
/// <param name="mappings">The mappings.</param>
private void MapAmpPageses(List <MappingConfiguration> mappings)
{
var mapping = new MappingConfiguration <AmpPage>();
mapping.MapType(p => new { }).SetTableName("AMP_AmpPages", this.Context);
mapping.HasProperty(p => p.Id).IsIdentity().IsNotNullable();
mapping.HasProperty(p => p.Title).IsNotNullable().IsText(this.Context, 255);
mapping.HasProperty(p => p.ItemType).IsText(this.Context, 255);
mapping.HasProperty(p => p.UrlName).IsText(this.Context, 255);
mapping.HasProperty(p => p.PageId);
mapping.HasProperty(p => p.FieldsListJson).IsNullable().WithInfiniteLength();
mapping.HasProperty(p => p.ApplicationName);
mapping.HasProperty(p => p.LastModified);
mapping.HasProperty(p => p.DateCreated);
mapping.HasProperty(p => p.LayoutTemplatePath).IsText(this.Context, 255);
mapping.HasProperty(p => p.TemplatePath).IsText(this.Context, 255);
mapping.HasProperty(p => p.PageUrl).IsText(this.Context);
mapping.HasIndex(p => p.Title).IsUnique().WithName("idx_title");
mapping.HasIndex(p => p.UrlName).IsUnique().WithName("idx_urlName");
mapping.HasIndex(p => p.PageId).IsUnique().WithName("idx_pageId");
mappings.Add(mapping);
}
/// <summary>
/// Maps the ProjectItemUrlData class
/// </summary>
/// <param name="mappings">The LocatoinItemUrlData class mappings.</param>
private void MapUrlData(IList<MappingConfiguration> mappings)
{
// map the Url data type
var urlDataMapping = new MappingConfiguration<ProjectItemUrlData>();
urlDataMapping.MapType(p => new { }).Inheritance(InheritanceStrategy.Flat).ToTable("sf_url_data");
mappings.Add(urlDataMapping);
}
private void MapItem(IList <MappingConfiguration> mappings)
{
var itemMapping = new MappingConfiguration <RealEstateItem>();
itemMapping.HasProperty(p => p.Id).IsIdentity();
itemMapping.MapType(p => new { }).ToTable("sfex_realestate_item");
itemMapping.HasProperty(p => p.ItemNumber);
itemMapping.HasProperty(p => p.Address);
itemMapping.HasProperty(p => p.PostalCode);
itemMapping.HasProperty(p => p.Housing);
itemMapping.HasProperty(p => p.NumberOfRooms);
itemMapping.HasProperty(p => p.NumberOfFloors);
itemMapping.HasProperty(p => p.YearBuilt);
itemMapping.HasProperty(p => p.Price);
itemMapping.HasProperty(p => p.Payment);
itemMapping.HasProperty(p => p.MonthlyRate);
itemMapping.HasProperty(p => p.Net);
itemMapping.HasProperty(p => p.PriceSquareMeter);
itemMapping.HasProperty(p => p.Latitude);
itemMapping.HasProperty(p => p.Longitude);
itemMapping.HasProperty(p => p.AgentId);
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 <RealEstateItem>(itemMapping, this.Context);
mappings.Add(itemMapping);
}
public MappingConfiguration<Team> GetTeamClassConfiguration()
{
MappingConfiguration<Team> configuration = new MappingConfiguration<Team>();
configuration.MapType().WithDataAccessKind(DataAccessKind.ReadWrite);
return configuration;
}
public MappingConfiguration <VRTileconfig> GetVRTileconfigClassConfiguration()
{
MappingConfiguration <VRTileconfig> configuration = new MappingConfiguration <VRTileconfig>();
configuration.MapType(x => new { }).WithConcurencyControl(OptimisticConcurrencyControlStrategy.Changed).ToTable("VRTileconfigs");
return(configuration);
}
public MappingConfiguration <VRBookingReference> GetVRBookingReferenceClassConfiguration()
{
MappingConfiguration <VRBookingReference> configuration = new MappingConfiguration <VRBookingReference>();
configuration.MapType(x => new { }).WithCascadeDelete(CascadeDeleteOption.No).ToTable("VRBookingReferences");
return(configuration);
}
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 MapUrlData(IList <MappingConfiguration> mappings)
{
var urlDataMapping = new MappingConfiguration <ProductItemUrlData>();
urlDataMapping.MapType(p => new { }).Inheritance(InheritanceStrategy.Flat).ToTable("sf_url_data");
mappings.Add(urlDataMapping);
}
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);
}
private void MapUrlData(IList <MappingConfiguration> mappings)
{
var urlDataMapping = new MappingConfiguration <AgentItemUrlData>();
urlDataMapping.MapType(p => new { }).Inheritance(InheritanceStrategy.Flat).ToTable("sfex_agent_item_urls");
mappings.Add(urlDataMapping);
}
protected override IList<MappingConfiguration> PrepareMapping()
{
List<MappingConfiguration> configurations = new List<MappingConfiguration>();
MappingConfiguration<Report> reportConfiguration = new MappingConfiguration<Report>();
reportConfiguration.MapType(x => new
{
ID = x.Id,
Name = x.Name,
Duration = x.Duration,
Destination = x.Destination,
ClientsCount = x.ClientsCount,
TotalIncome = x.TotalIncome,
TransportCompany = x.TransportCompany,
TransportType = x.TransportType,
GuideName = x.GuideName,
ExpenseId = x.ExpenseId
}).ToTable("Reports");
reportConfiguration.HasProperty(p => p.Id).IsIdentity(KeyGenerator.Autoinc);
configurations.Add(reportConfiguration);
return configurations;
}
protected override IList<MappingConfiguration> PrepareMapping()
{
List<MappingConfiguration> configurations = new List<MappingConfiguration>();
var saleMapping = new MappingConfiguration<Sale>();
saleMapping.MapType(sale => new
{
ID = sale.Id,
Dish = sale.Dish,
Quantity = sale.Quantity,
Month = sale.Month,
Year = sale.Year
}).ToTable("Sale");
saleMapping.HasProperty(s => s.Id).IsIdentity();
configurations.Add(saleMapping);
var dishReportMapping = new MappingConfiguration<DishReport>();
dishReportMapping.MapType(report => new
{
Month = report.Month,
DeliveredPrice = report.DeliveredPrice,
SoldPrice = report.SoldPrice,
Code = report.Code,
}).ToTable("DishReport");
saleMapping.HasProperty(s => s.Id).IsIdentity();
configurations.Add(dishReportMapping);
return configurations;
}
public MappingConfiguration <VRTicketType> GetVRTicketTypeClassConfiguration()
{
MappingConfiguration <VRTicketType> configuration = new MappingConfiguration <VRTicketType>();
configuration.MapType(x => new { }).ToTable("VRTicketTypes");
return(configuration);
}
public MappingConfiguration<RentalRate> GetRentalRateClassConfiguration()
{
MappingConfiguration<RentalRate> configuration = new MappingConfiguration<RentalRate>();
configuration.MapType(x => new { }).WithConcurencyControl(OptimisticConcurrencyControlStrategy.Changed).ToTable("RentalRates");
return configuration;
}
public MappingConfiguration <RentalRate> GetRentalRateClassConfiguration()
{
MappingConfiguration <RentalRate> configuration = new MappingConfiguration <RentalRate>();
configuration.MapType(x => new { }).WithConcurencyControl(OptimisticConcurrencyControlStrategy.Changed).ToTable("RentalRates");
return(configuration);
}
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;
}
public MappingConfiguration <Header> GetHeaderClassConfiguration()
{
MappingConfiguration <Header> configuration = new MappingConfiguration <Header>();
configuration.MapType(x => new { }).WithDataAccessKind(DataAccessKind.Default);
return(configuration);
}
public MappingConfiguration <Position> GetPositionClassConfiguration()
{
MappingConfiguration <Position> configuration = new MappingConfiguration <Position>();
configuration.MapType(x => new { }).WithDataAccessKind(DataAccessKind.Default);
return(configuration);
}
public MappingConfiguration <ThingSource> GetThingSourceClassConfiguration()
{
MappingConfiguration <ThingSource> configuration = new MappingConfiguration <ThingSource>();
configuration.MapType().WithDataAccessKind(DataAccessKind.ReadWrite);
return(configuration);
}
public MappingConfiguration <Shipper> GetShipperClassConfiguration()
{
MappingConfiguration <Shipper> configuration = new MappingConfiguration <Shipper>();
configuration.MapType(x => new { }).WithConcurencyControl(OptimisticConcurrencyControlStrategy.Changed).ToTable("Shippers");
return(configuration);
}
public MappingConfiguration <OrderDetail> GetOrderDetailClassConfiguration()
{
MappingConfiguration <OrderDetail> configuration = new MappingConfiguration <OrderDetail>();
configuration.MapType(x => new { }).WithConcurencyControl(OptimisticConcurrencyControlStrategy.Changed).ToTable("Order Details");
return(configuration);
}
public MappingConfiguration <Product> GetProductClassConfiguration()
{
MappingConfiguration <Product> configuration = new MappingConfiguration <Product>();
configuration.MapType(x => new { }).WithConcurencyControl(OptimisticConcurrencyControlStrategy.Changed).ToTable("Products");
return(configuration);
}
public MappingConfiguration <TeamMember> GetTeamMemberClassConfiguration()
{
MappingConfiguration <TeamMember> configuration = new MappingConfiguration <TeamMember>();
configuration.MapType().WithDataAccessKind(DataAccessKind.ReadWrite);
return(configuration);
}
public MappingConfiguration <CustomerDemographic> GetCustomerDemographicClassConfiguration()
{
MappingConfiguration <CustomerDemographic> configuration = new MappingConfiguration <CustomerDemographic>();
configuration.MapType(x => new { }).WithConcurencyControl(OptimisticConcurrencyControlStrategy.Changed).ToTable("CustomerDemographics");
return(configuration);
}
public MappingConfiguration <Territory> GetTerritoryClassConfiguration()
{
MappingConfiguration <Territory> configuration = new MappingConfiguration <Territory>();
configuration.MapType(x => new { }).WithConcurencyControl(OptimisticConcurrencyControlStrategy.Changed).ToTable("Territories");
return(configuration);
}
public MappingConfiguration <EmailLog> GetEmailLogClassConfiguration()
{
MappingConfiguration <EmailLog> configuration = new MappingConfiguration <EmailLog>();
configuration.MapType().WithDataAccessKind(DataAccessKind.ReadWrite);
return(configuration);
}
public MappingConfiguration <UserProfile> GetUserProfileClassConfiguration()
{
MappingConfiguration <UserProfile> configuration = new MappingConfiguration <UserProfile>();
configuration.MapType(x => new { });
return(configuration);
}
public MappingConfiguration <Registrant> GetRegistrantClassConfiguration()
{
MappingConfiguration <Registrant> configuration = new MappingConfiguration <Registrant>();
configuration.MapType(x => new { }).WithCascadeDelete(CascadeDeleteOption.No);
return(configuration);
}
private MappingConfiguration <ObiektBiznesowyBazowy> PobierzMapping()
{
var customerMapping = new MappingConfiguration <ObiektBiznesowyBazowy>();
customerMapping.MapType().Inheritance(Telerik.OpenAccess.InheritanceStrategy.Horizontal);
customerMapping.HasProperty(c => c.Id).IsIdentity();
return(customerMapping);
}
public MappingConfiguration <ThingBase> GetThingBaseClassConfiguration()
{
MappingConfiguration <ThingBase> configuration = new MappingConfiguration <ThingBase>();
configuration.MapType().WithDataAccessKind(DataAccessKind.ReadWrite).Inheritance(InheritanceStrategy.Default).ToTable("thing_base");
return(configuration);
}
public MappingConfiguration<DataAccessIncome> GetDataAccessIncomeClassConfiguration()
{
MappingConfiguration<DataAccessIncome> configuration = new MappingConfiguration<DataAccessIncome>();
configuration.MapType(x => new { })
.WithConcurencyControl(OptimisticConcurrencyControlStrategy.Changed)
.ToTable("incomes");
return configuration;
}
public MappingConfiguration<JobSchedule> GetJobScheduleClassConfiguration()
{
var configuration = new MappingConfiguration<JobSchedule>();
configuration.MapType(x => new { })
.WithConcurencyControl(Changed)
.ToTable("js_JobSchedules");
return configuration;
}
public static MappingConfiguration <SmsKonto> PobierzMapping()
{
var customerMapping = new MappingConfiguration <SmsKonto>();
customerMapping.MapType();
MapujPropercjeBazowe(customerMapping);
return(customerMapping);
}
/// <summary>
/// Maps the file data.
/// </summary>
/// <param name="mappings">The mappings.</param>
private void MapFileData(List<MappingConfiguration> mappings)
{
var fileDataMapping = new MappingConfiguration<FileData>();
fileDataMapping.MapType(p => new { }).WithConcurencyControl(OptimisticConcurrencyControlStrategy.None).ToTable("sf_files_monitor_data");
fileDataMapping.HasProperty(p => p.Id).IsIdentity();
fileDataMapping.HasProperty(p => p.FileName).ToColumn("file_name");
fileDataMapping.HasProperty(p => p.FilePath).ToColumn("file_path");
fileDataMapping.HasProperty(p => p.PackageName).ToColumn("package_name");
mappings.Add(fileDataMapping);
}
private MappingConfiguration<IdentityRole> CreateIdentityRoleMapping()
{
MappingConfiguration<IdentityRole> identityRoleMapping = new MappingConfiguration<IdentityRole>();
identityRoleMapping.MapType(role => new
{
id = role.Id,
Name = role.Name
}).ToTable("IdentityRoles");
identityRoleMapping.HasProperty(x => x.Id).IsIdentity();
return identityRoleMapping;
}
private MappingConfiguration<IdentityUser> CraeteIdentityUserMapping()
{
MappingConfiguration<IdentityUser> identityUserMapping = new MappingConfiguration<IdentityUser>();
identityUserMapping.MapType(user => new
{
Id = user.Id,
Name = user.UserName,
PasswordHash = user.PasswordHash
}).ToTable("IdentityUsers");
identityUserMapping.HasProperty(x => x.Id).IsIdentity();
return identityUserMapping;
}
private MappingConfiguration<CLASSNAME> GetTable()
{
MappingConfiguration<Position> configuration = new MappingConfiguration<CLASSNAME>();
configuration.MapType()
.Inheritance(Telerik.OpenAccess.InheritanceStrategy.Flat)
.WithConcurencyControl(OptimisticConcurrencyControlStrategy.Version);
configuration.HasProperty(x => x.Id).IsIdentity(KeyGenerator.Autoinc);
//configuration.HasIndex(x => new {
// x.Price,
// x.ProductName
//}).IsUnique()
//.IsClustered()
return configuration;
}
protected override IList<MappingConfiguration> PrepareMapping()
{
List<MappingConfiguration> configurations = new List<MappingConfiguration>();
var stefan = new MappingConfiguration<Stefan>();
stefan.MapType(s => new
{
ID = s.StefanID,
Name = s.Name,
}).ToTable("Stefan");
stefan.HasProperty(s => s.StefanID).IsIdentity();
configurations.Add(stefan);
return configurations;
}
public static MappingConfiguration GetMapping()
{
var mapping = new MappingConfiguration<Instance>();
mapping.MapType().ToTable("Instances");
mapping.HasProperty(p => p.SurrogateInstanceId).IsIdentity(KeyGenerator.Autoinc);
mapping.HasProperty(p => p.PrimitiveDataProperties).WithInfiniteLength().IsNullable();
mapping.HasProperty(p => p.ComplexDataProperties).WithInfiniteLength().IsNullable();
mapping.HasProperty(p => p.WriteOnlyPrimitiveDataProperties).WithInfiniteLength().IsNullable();
mapping.HasProperty(p => p.WriteOnlyComplexDataProperties).WithInfiniteLength().IsNullable();
mapping.HasProperty(p => p.MetadataProperties).WithInfiniteLength().IsNullable();
mapping.HasProperty(p => p.SuspensionExceptionName).WithVariableLength(450).IsNullable().IsUnicode();
mapping.HasProperty(p => p.SuspensionReason).WithInfiniteLength().IsUnicode().IsNullable();
mapping.HasProperty(p => p.BlockingBookmarks).WithInfiniteLength().IsUnicode().IsNullable();
mapping.HasProperty(p => p.LastMachineRunOn).WithVariableLength(450).IsUnicode().IsNullable();
return mapping;
}
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);
}
protected override IList<MappingConfiguration> PrepareMapping()
{
IList<MappingConfiguration> result = new List<MappingConfiguration>();
MappingConfiguration<Category> productConfiguration = new MappingConfiguration<Category>();
productConfiguration.MapType(x => new
{
CategoryId = x.Id,
CategoryName = x.Name,
Description = x.Description
}).ToTable("Categories");
productConfiguration.HasProperty(x => x.Id).IsIdentity(KeyGenerator.Autoinc);
result.Add(productConfiguration);
return result;
}
protected override IList<MappingConfiguration> PrepareMapping()
{
List<MappingConfiguration> configurations = new List<MappingConfiguration>();
var mediaMapping = new MappingConfiguration<MySqlMediaModel>();
mediaMapping.MapType(m => new
{
Id = m.Id,
Name = m.Name,
Distributor = m.Distributor,
TotalSells = m.TotalSells,
Incomes = m.Incomes
}).ToTable("Packages");
mediaMapping.HasProperty(p => p.Id).IsIdentity(KeyGenerator.Autoinc);
configurations.Add(mediaMapping);
return configurations;
}
protected override IList<MappingConfiguration> PrepareMapping()
{
List<MappingConfiguration> configurations =
new List<MappingConfiguration>();
var weaponMapping = new MappingConfiguration<WeaponReport>();
weaponMapping.MapType(wr => new
{
Id = wr.weaponId,
Name = wr.weaponName,
EmailAddress = wr.manufacturer,
}).ToTable("Weapon Reports");
weaponMapping.HasProperty(c => c.weaponId).IsIdentity();
configurations.Add(weaponMapping);
return configurations;
}
protected override IList<MappingConfiguration> PrepareMapping()
{
List<MappingConfiguration> configurations = new List<MappingConfiguration>();
var modelMapping = new MappingConfiguration<MakersProfit>();
modelMapping.MapType(r => new
{
Id = r.MakerId,
Name = r.MakerName,
Profit = r.Profit
}).ToTable("Reports");
modelMapping.HasProperty(r => r.MakerId).IsIdentity();
configurations.Add(modelMapping);
return configurations;
}
private static MappingConfiguration<Category> GetCategoryMapping()
{
MappingConfiguration<Category> result = new MappingConfiguration<Category>();
result.MapType(x => new
{
CategoryID = x.Id,
CategoryName = x.Name,
Description = x.Description
}).
ToTable("Categories");
result.HasProperty(x => x.Id).IsIdentity(KeyGenerator.Autoinc);
result.HasProperty(x => x.Name).WithFixedLength(50);
result.HasProperty(x => x.Description).WithInfiniteLength();
result.HasIndex(x => x.Name).WithName("IX_Category").IsUnique();
return result;
}
/// <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);
}
protected override IList<MappingConfiguration> PrepareMapping()
{
List<MappingConfiguration> configurations =
new List<MappingConfiguration>();
var salesMapping = new MappingConfiguration<SalesTotalCostReport>();
salesMapping.MapType(report => new
{
Id = report.Id,
Name = report.Name,
TotalCost = report.TotalCost,
}).ToTable("Sales");
salesMapping.HasProperty(c => c.Id).IsIdentity();
configurations.Add(salesMapping);
return configurations;
}
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;
}
protected override IList<MappingConfiguration> PrepareMapping()
{
List<MappingConfiguration> configurations = new List<MappingConfiguration>();
var reportsMapping = new MappingConfiguration<ProductReport>();
reportsMapping.MapType(sale => new
{
MedicamentId = sale.MedicamentId,
MedicamentName = sale.MedicamentName,
VendorName = sale.ManufacturerName,
Quantity = sale.Quantity,
Income = sale.Income
}).ToTable("Reports");
reportsMapping.HasProperty(c => c.MedicamentId).IsIdentity(KeyGenerator.HighLow);
configurations.Add(reportsMapping);
return configurations;
}
protected override IList<MappingConfiguration> PrepareMapping()
{
List<MappingConfiguration> configurations = new List<MappingConfiguration>();
var report = new MappingConfiguration<Report>();
report.MapType(r => new
{
ReportID = r.ReportId,
StoreName = r.StoreName,
ProductName = r.ProductName,
Quantity = r.Quantity,
Price = r.Price,
Sun = r.Sum,
}).ToTable("Report");
report.HasProperty(r => r.ReportId).IsIdentity();
configurations.Add(report);
return configurations;
}
/// <summary>
/// prepare for mapping
/// </summary>
/// <returns>configuration to map</returns>
protected override IList<MappingConfiguration> PrepareMapping()
{
List<MappingConfiguration> configurations = new List<MappingConfiguration>();
var mySqlMapping = new MappingConfiguration<MonthlyNumberOfContracts>();
mySqlMapping.MapType(report => new
{
Id = report.Id,
Date = report.Date,
NumberOfContracts = report.NumberOfContracts
}).ToTable("MySql");
mySqlMapping.HasProperty(c => c.Id).IsIdentity(KeyGenerator.Autoinc);
configurations.Add(mySqlMapping);
return configurations;
}
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()
{
// Getting Started with the Fluent Mapping API
// http://documentation.telerik.com/openaccess-orm/developers-guide/code-only-mapping/fluent-mapping-overview
List<MappingConfiguration> configurations = new List<MappingConfiguration>();
MappingConfiguration<Product> productConfiguration = new MappingConfiguration<Product>();
productConfiguration.MapType(x => new
{
ID = x.ID,
Price = x.Price,
ProductName = x.ProductName
}).ToTable("Products");
productConfiguration.HasProperty(x => x.ID).IsIdentity(KeyGenerator.Autoinc);
configurations.Add(productConfiguration);
return configurations;
}
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;
}
