protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity <Category>().HasKey(c => c.Id);
modelBuilder.Entity <Product>().HasKey(p => p.Id);
modelBuilder.Entity <Category>()
.HasOptional(c => c.ParentCategory)
.WithMany(c => c.SubCategories)
.HasForeignKey(c => c.ParentCategoryId);
modelBuilder.Entity <Product>()
.HasRequired <Category>(p => p.Category)
.WithMany(c => c.Products)
.HasForeignKey(p => p.CategoryId);
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
modelBuilder.Entity <UserProfile>()
.HasMany <Technology>(s => s.InterestedIn)
.WithMany(c => c.UserProfiles)
.Map(cs =>
{
cs.MapLeftKey("UserProfileId");
cs.MapRightKey("TechnologyId");
cs.ToTable("UserTechnologies");
});
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
}
// PATCH tables/User/48D68C86-6EA6-4C25-AA33-223FC9A27959
public Task <IHttpActionResult> PatchUser(string id, Delta <User> patch)
{
string updateCommand = "INSERT INTO UserRelations (Followers, Following) VALUES = ('" +
patch.GetEntity().Followers + "','" + patch.GetEntity().Following + "');";
string command = String.Format(updateCommand, ServiceSettingsDictionary.GetSchemaName());
context.Database.ExecuteSqlCommandAsync(command);
return(null);
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention<TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
Configuration.ProxyCreationEnabled = true;
Configuration.LazyLoadingEnabled = true;
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
modelBuilder.Entity <Athlete>().ToTable("Athlete");
modelBuilder.Entity <League>().ToTable("League");
modelBuilder.Entity <Membership>().ToTable("Membership");
modelBuilder.Entity <Challenge>().ToTable("Challenge");
modelBuilder.Entity <GameResult>().ToTable("GameResult");
modelBuilder.Entity <Challenge>().HasRequired(a => a.ChallengeeAthlete)
.WithMany().HasForeignKey(a => a.ChallengeeAthleteId);
modelBuilder.Entity <Challenge>().HasRequired(a => a.ChallengerAthlete)
.WithMany().HasForeignKey(a => a.ChallengerAthleteId);
modelBuilder.Entity <Challenge>().HasRequired(a => a.League)
.WithMany().HasForeignKey(a => a.LeagueId);
modelBuilder.Entity <GameResult>().HasRequired(a => a.Challenge)
.WithMany().HasForeignKey(a => a.ChallengeId);
modelBuilder.Entity <GameResult>().HasRequired(g => g.Challenge)
.WithMany(c => c.MatchResult)
.HasForeignKey(g => g.ChallengeId);
modelBuilder.Entity <League>().HasOptional(a => a.CreatedByAthlete)
.WithMany().HasForeignKey(a => a.CreatedByAthleteId);
modelBuilder.Entity <Membership>().HasRequired(m => m.League)
.WithMany(l => l.Memberships)
.HasForeignKey(m => m.LeagueId);
modelBuilder.Entity <Challenge>().HasRequired(c => c.League)
.WithMany(l => l.Challenges)
.HasForeignKey(m => m.LeagueId);
modelBuilder.Entity <Membership>().HasRequired(m => m.Athlete)
.WithMany(a => a.Memberships)
.HasForeignKey(m => m.AthleteId);
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
Database.SetInitializer <JobDbContext>(null);
base.OnModelCreating(modelBuilder);
}
public static void Register()
{
// Use this class to set configuration options for your mobile service
ConfigOptions options = new ConfigOptions();
// Use this class to set WebAPI configuration options
HttpConfiguration config = ServiceConfig.Initialize(new ConfigBuilder(options));
// To display errors in the browser during development, uncomment the following
// line. Comment it out again when you deploy your service for production use.
// config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
Database.SetInitializer(new TicTacToeMobileServiceInitializer(ServiceSettingsDictionary.GetSchemaName()));
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
modelBuilder.Entity <EventItem>()
.HasMany(eventItem => eventItem.ParticipantItems)
.WithMany(participant => participant.EventItems);
modelBuilder.Entity <EventItem>()
.HasOptional(eventItem => eventItem.PlaceItem)
.WithMany(placeItem => placeItem.EventItems);
}
/// <summary>
/// The on model creating.
/// </summary>
/// <param name="modelBuilder">
/// The model builder.
/// </param>
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
modelBuilder.Entity <Customer>()
.HasMany(e => e.Orders)
.WithRequired(e => e.Customer)
.HasForeignKey(e => e.CustomerId)
.WillCascadeOnDelete(false);
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
modelBuilder.Entity <Travel>()
.HasMany(t => t.Categories)
.WithRequired()
.WillCascadeOnDelete(true);
modelBuilder.Entity <Categorie>()
.HasMany(c => c.Items)
.WithRequired()
.WillCascadeOnDelete(true);
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity <Account>().HasKey(a => a.Id);
modelBuilder.Entity <Order>().HasKey(o => o.Id);
modelBuilder.Entity <Category>().HasKey(c => c.Id);
modelBuilder.Entity <Product>().HasKey(p => p.Id);
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
/*
* The following line of code is part of the VS template.
* It creates a column annotation "ServiceTableColumn" for data fields with attribute [TableColumn].
* E.g.: The attribute [TableColumn(TableColumnType.UpdatedAt)] will be translated to a
* column annotation "UpdatedAt".
* This annotation enables the entity framework to automatically fill the corresponding fields
* when according actions took place.
*/
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
modelBuilder.Entity <User>()
.HasMany <User>(u => u.Followers)
.WithMany(c => c.Following)
.Map(cs =>
{
cs.MapLeftKey("Followers");
cs.MapRightKey("Following");
cs.ToTable("UserRelations");
});
}
public MobileServiceContext()
: base(connectionStringName)
{
this.Schema = ServiceSettingsDictionary.GetSchemaName();
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
// I happen to like my table names to be singular
modelBuilder.Conventions.Remove <PluralizingTableNameConvention>();
// set the Id column of every to be the PK
modelBuilder.Properties <string>()
.Where(p => p.Name == "Id")
.Configure(p => p.IsKey());
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
modelBuilder.Entity <Profile>()
.Property(m => m.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
modelBuilder.Entity <Training>()
.Property(m => m.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
modelBuilder.Entity <School>()
.Property(m => m.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
modelBuilder.Entity <Event>()
.Property(m => m.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
modelBuilder.Entity <Location>()
.Property(m => m.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
// map Profile to Training and back
modelBuilder.Entity <Training>().HasRequired(t => t.Profile)
.WithMany(p => p.Training)
.HasForeignKey(t => t.ProfileId);
// map Event to Location and back
modelBuilder.Entity <Event>().HasRequired(e => e.Location)
.WithMany(l => l.Events)
.HasForeignKey(e => e.LocationId);
// map School to Location
modelBuilder.Entity <School>().HasRequired(s => s.Location)
.WithMany()
.HasForeignKey(s => s.LocationId);
// map Reviews to School and back
modelBuilder.Entity <Review>().HasRequired(r => r.School)
.WithMany(s => s.Reviews)
.HasForeignKey(r => r.SchoolId);
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
var schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
//modelBuilder.Entity<Apartment>().Property(x => x.Latitude).HasPrecision(20, 20);
//modelBuilder.Entity<Apartment>().Property(x => x.Longitude).HasPrecision(20, 20);
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
/***********************
* User *
***********************/
// User + Profile
modelBuilder.Entity <User>()
.HasOptional(s => s.Profile)
.WithRequired(ad => ad.User)
.WillCascadeOnDelete(false);
// User + Account
modelBuilder.Entity <User>()
.HasMany(s => s.Accounts)
.WithRequired(s => s.User)
.HasForeignKey(s => s.UserId)
.WillCascadeOnDelete(false);
// User + Apartment
modelBuilder.Entity <User>()
.HasMany(s => s.Apartments)
.WithRequired(s => s.User)
.HasForeignKey(s => s.UserId)
.WillCascadeOnDelete(false);
// User + Card
modelBuilder.Entity <User>()
.HasMany(s => s.Cards)
.WithRequired(s => s.User)
.HasForeignKey(s => s.UserId)
.WillCascadeOnDelete(false);
// User + Favorite
modelBuilder.Entity <User>()
.HasMany(s => s.Favorites)
.WithRequired(s => s.User)
.HasForeignKey(s => s.UserId)
.WillCascadeOnDelete(false);
// User + Notification
modelBuilder.Entity <User>()
.HasMany(s => s.Notifications)
.WithRequired(s => s.User)
.HasForeignKey(s => s.UserId)
.WillCascadeOnDelete(false);
// User + Reservation
modelBuilder.Entity <User>()
.HasMany(s => s.Reservations)
.WithRequired(s => s.User)
.HasForeignKey(s => s.UserId)
.WillCascadeOnDelete(false);
// User + Review
modelBuilder.Entity <User>()
.HasMany(s => s.OutReviews)
.WithRequired(s => s.FromUser)
.HasForeignKey(s => s.FromUserId)
.WillCascadeOnDelete(false);
modelBuilder.Entity <User>()
.HasMany(s => s.InReviews)
.WithRequired(s => s.ToUser)
.HasForeignKey(s => s.ToUserId)
.WillCascadeOnDelete(false);
modelBuilder.Entity <User>()
.HasMany(s => s.Feedbacks)
.WithOptional(s => s.User)
.HasForeignKey(s => s.UserId)
.WillCascadeOnDelete(false);
modelBuilder.Entity <User>()
.HasMany(s => s.Appeals)
.WithOptional(s => s.Abuser)
.HasForeignKey(s => s.AbuserId)
.WillCascadeOnDelete(false);
//Apartment
modelBuilder.Entity <Apartment>()
.HasMany(s => s.Cards)
.WithOptional(s => s.Apartment)
.HasForeignKey(s => s.ApartmentId)
.WillCascadeOnDelete(false);
modelBuilder.Entity <Apartment>()
.HasMany(s => s.Pictures)
.WithMany(c => c.Apartments)
.Map(cs =>
{
cs.MapLeftKey("ApartmentRefId");
cs.MapRightKey("PictureRefId");
cs.ToTable("ApartmentPicture");
});
// Card
modelBuilder.Entity <Card>()
.HasMany(s => s.Dates)
.WithRequired(s => s.Card)
.HasForeignKey(s => s.CardId)
.WillCascadeOnDelete(false);
modelBuilder.Entity <Card>()
.HasMany(s => s.Genders)
.WithRequired(s => s.Card)
.HasForeignKey(s => s.CardId)
.WillCascadeOnDelete(false);
modelBuilder.Entity <Card>()
.HasMany(s => s.Reservations)
.WithRequired(s => s.Card)
.HasForeignKey(s => s.CardId)
.WillCascadeOnDelete(false);
modelBuilder.Entity <Card>()
.HasMany(s => s.Favorites)
.WithRequired(s => s.Card)
.HasForeignKey(s => s.CardId)
.WillCascadeOnDelete(false);
modelBuilder.Entity <Card>()
.HasMany(s => s.Notifications)
.WithOptional(s => s.Card)
.HasForeignKey(s => s.CardId)
.WillCascadeOnDelete(false);
modelBuilder.Entity <Card>()
.HasMany(s => s.Pictures)
.WithMany(c => c.Cards)
.Map(cs =>
{
cs.MapLeftKey("CardRefId");
cs.MapRightKey("PictureRefId");
cs.ToTable("CardPicture");
});
// Reservation
modelBuilder.Entity <Reservation>()
.HasMany(s => s.Notifications)
.WithOptional(s => s.Reservation)
.HasForeignKey(s => s.ReservationId)
.WillCascadeOnDelete(false);
// Review
modelBuilder.Entity <Review>()
.HasMany(s => s.Notifications)
.WithOptional(s => s.Review)
.HasForeignKey(s => s.ReviewId)
.WillCascadeOnDelete(false);
//Favorite
modelBuilder.Entity <Favorite>()
.HasMany(s => s.Notifications)
.WithOptional(s => s.Favorite)
.HasForeignKey(s => s.FavoriteId)
.WillCascadeOnDelete(true);
// Picture + Profile
modelBuilder.Entity <Picture>()
.HasMany(s => s.Profiles)
.WithOptional(s => s.Picture)
.HasForeignKey(s => s.PictureId);
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
string schema = ServiceSettingsDictionary.GetSchemaName();
if (!string.IsNullOrEmpty(schema))
{
modelBuilder.HasDefaultSchema(schema);
}
else
{
modelBuilder.HasDefaultSchema("dbo");
}
modelBuilder.Conventions.Add(
new AttributeToColumnAnnotationConvention <TableColumnAttribute, string>(
"ServiceTableColumn", (property, attributes) => attributes.Single().ColumnType.ToString()));
modelBuilder.Entity <Customer>()
.Property(e => e.AdditionalContactNumber)
.IsUnicode(false);
modelBuilder.Entity <Customer>()
.Property(e => e.County)
.IsUnicode(false);
modelBuilder.Entity <Customer>()
.Property(e => e.FullName)
.IsUnicode(false);
modelBuilder.Entity <Customer>()
.Property(e => e.HouseNumberOrName)
.IsUnicode(false);
modelBuilder.Entity <Customer>()
.Property(e => e.Id)
.IsUnicode(false);
modelBuilder.Entity <Customer>()
.Property(e => e.Latitude)
.HasPrecision(9, 6);
modelBuilder.Entity <Customer>()
.Property(e => e.Longitude)
.HasPrecision(9, 6);
modelBuilder.Entity <Customer>()
.Property(e => e.Postcode)
.IsUnicode(false);
modelBuilder.Entity <Customer>()
.Property(e => e.PrimaryContactNumber)
.IsUnicode(false);
modelBuilder.Entity <Customer>()
.Property(e => e.Street)
.IsUnicode(false);
modelBuilder.Entity <Customer>()
.Property(e => e.Town)
.IsUnicode(false);
modelBuilder.Entity <Equipment>()
.Property(e => e.Description)
.IsUnicode(false);
modelBuilder.Entity <Equipment>()
.Property(e => e.Id)
.IsUnicode(false);
modelBuilder.Entity <Equipment>()
.Property(e => e.EquipmentNumber)
.IsUnicode(false);
modelBuilder.Entity <Equipment>()
.Property(e => e.FullImage)
.IsUnicode(false);
modelBuilder.Entity <Equipment>()
.Property(e => e.Name)
.IsUnicode(false);
modelBuilder.Entity <Equipment>()
.Property(e => e.ThumbImage)
.IsUnicode(false);
modelBuilder.Entity <Equipment>()
.HasMany(e => e.Jobs)
.WithMany(e => e.Equipments)
.Map(m => m.ToTable("EquipmentIds").MapLeftKey("EquipmentId").MapRightKey("JobId"));
modelBuilder.Entity <Job>()
.Property(e => e.CustomerId)
.IsUnicode(false);
modelBuilder.Entity <Job>()
.Property(e => e.EtaTime)
.IsUnicode(false);
modelBuilder.Entity <Job>()
.Property(e => e.Id)
.IsUnicode(false);
modelBuilder.Entity <Job>()
.Property(e => e.JobNumber)
.IsUnicode(false);
modelBuilder.Entity <Job>()
.Property(e => e.Status)
.IsUnicode(false);
modelBuilder.Entity <Job>()
.Property(e => e.Title)
.IsUnicode(false);
modelBuilder.Entity <JobHistory>()
.Property(e => e.ActionBy)
.IsUnicode(false);
modelBuilder.Entity <JobHistory>()
.Property(e => e.Comments)
.IsUnicode(false);
modelBuilder.Entity <JobHistory>()
.Property(e => e.JobId)
.IsUnicode(false);
modelBuilder.Entity <JobHistory>()
.Property(e => e.Id)
.IsUnicode(false);
}
