IEnumerable<DataGridColumn> SearchRow(EventRecordProxy proxy, string pattern)
{
if (proxy.Id.ToString().IndexOf(pattern, 0, StringComparison.OrdinalIgnoreCase) >= 0)
{
yield return GridColumns["Id"];
}
if (GuidToStringConverter.ToString(proxy.ActivityId).IndexOf(pattern, 0, StringComparison.OrdinalIgnoreCase) >= 0)
{
yield return GridColumns["ActivityId"];
}
if (GuidToStringConverter.ToString(proxy.RelatedActivityId).IndexOf(pattern, 0, StringComparison.OrdinalIgnoreCase) >= 0)
{
yield return GridColumns["RelatedActivityId"];
}
if (proxy.Symbol.IndexOf(pattern, 0, StringComparison.OrdinalIgnoreCase) >= 0)
{
yield return GridColumns["Symbol"];
}
if (proxy.Message.IndexOf(pattern, 0, StringComparison.OrdinalIgnoreCase) >= 0)
{
yield return GridColumns["Message"];
}
}
public void ConvertStringBackToGuid()
{
var converter = new GuidToStringConverter();
var actual = converter.ConvertBack(TEST_GUID);
actual.Should().Be(Guid.Parse(TEST_GUID));
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var converter = new GuidToStringConverter();
modelBuilder.Entity <TandemUser>().ToContainer("TandemUsers");
modelBuilder.Entity <TandemUser>().Property("UserId").HasConversion(converter);
modelBuilder.Entity <TandemUser>().HasPartitionKey(x => x.EmailAddress);
}
protected override void ConfigureEventStorage(EntityTypeBuilder <PersistedEvent> builder)
{
builder.ToTable("Event");
builder.Property(x => x.PersistenceId).UseOracleIdentityColumn();
var converter = new GuidToStringConverter();
builder.Property(x => x.EventId).HasConversion(converter).HasColumnType("VARCHAR2(200)"); // For troubleshooting
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var guidToStringConverter = new GuidToStringConverter();
// Instances
modelBuilder.Entity <Instance>()
.ToContainer("Instances")
.HasPartitionKey(e => e.UserId);
modelBuilder.Entity <Instance>(instance =>
{
instance.Property(e => e.Id).HasValueGenerator <GuidValueGenerator>();
instance.Property(e => e.UserId).HasConversion(guidToStringConverter);
});
modelBuilder.Entity <Instance>().OwnsOne(e => e.Truck, truck =>
{
truck.OwnsOne(e => e.FrontAxle);
truck.OwnsOne(e => e.RearAxle);
truck.Ignore(e => e.Items);
});
modelBuilder.Entity <Instance>().OwnsMany(e => e.Items, item =>
{
item.Ignore(e => e.Position);
});
// Users
modelBuilder.Entity <User>()
.ToContainer("Users")
.HasPartitionKey(e => e.Username);
modelBuilder.Entity <User>(instance =>
{
instance.Property(e => e.Id).HasValueGenerator <GuidValueGenerator>();
});
// Results
modelBuilder.Entity <Result>()
.ToContainer("Results")
.HasPartitionKey(e => e.UserId);
modelBuilder.Entity <Result>(result =>
{
result.Property(e => e.Id).HasValueGenerator <GuidValueGenerator>();
result.Property(e => e.UserId).HasConversion(guidToStringConverter);
result.Property(e => e.InstanceId).HasConversion(guidToStringConverter);
});
modelBuilder.Entity <Result>().OwnsMany(e => e.Trucks, truck =>
{
truck.OwnsOne(e => e.FrontAxle);
truck.OwnsOne(e => e.RearAxle);
truck.OwnsMany(e => e.Items);
});
base.OnModelCreating(modelBuilder);
}
public void Configure(EntityTypeBuilder <Profile> aEntityTypeBuilder)
{
var guidToStringConverter = new GuidToStringConverter();
aEntityTypeBuilder
.Property(nameof(Profile.Guid))
.HasConversion(guidToStringConverter);
aEntityTypeBuilder
.ToContainer($"{nameof(Profile)}s")
.HasNoDiscriminator()
.HasPartitionKey(aProfile => aProfile.Guid)
.HasKey(aProfile => aProfile.Guid);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var guidConverter = new GuidToStringConverter();
modelBuilder.Entity <UserModel>().HasKey(k => k.Id);
modelBuilder.Entity <UserModel>().Property(p => p.Id).HasConversion(guidConverter);
modelBuilder.Entity <UserModel>().HasIndex(b => b.Email).IsUnique();
modelBuilder.Entity <ProjectModel>().HasKey(k => k.Id);
modelBuilder.Entity <ProjectModel>().Property(p => p.Id).HasConversion(guidConverter);
modelBuilder.Entity <TaskModel>().HasKey(k => k.Id);
modelBuilder.Entity <TaskModel>().Property(p => p.Id).HasConversion(guidConverter);
modelBuilder.Entity <TagModel>().HasKey(k => k.Id);
modelBuilder.Entity <TagModel>().Property(p => p.Id).HasConversion(guidConverter);
modelBuilder.Entity <UserModel>()
.HasMany(c => c.Tags)
.WithOne(s => s.Owner)
.IsRequired()
.OnDelete(DeleteBehavior.Cascade);
modelBuilder.Entity <UserModel>()
.HasMany(c => c.Projects)
.WithOne(s => s.Owner)
.IsRequired()
.OnDelete(DeleteBehavior.Cascade);
modelBuilder.Entity <ProjectModel>()
.HasMany(c => c.Tasks)
.WithOne(s => s.Project)
.IsRequired()
.OnDelete(DeleteBehavior.Cascade);
modelBuilder.Entity <MMProjectTag>().HasKey(sc => new { sc.ProjectId, sc.TagId });
modelBuilder.Entity <MMProjectTag>()
.HasOne(pt => pt.Project)
.WithMany(p => p.ProjectTags)
.HasForeignKey(pt => pt.ProjectId);
modelBuilder.Entity <MMProjectTag>()
.HasOne(pt => pt.Tag)
.WithMany(t => t.ProjectTags)
.HasForeignKey(pt => pt.TagId);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
var guidToString = new GuidToStringConverter();
modelBuilder
.Entity <EarModel>()
.Property(e => e.Id)
.HasConversion(guidToString);
modelBuilder
.Entity <QuizModel>()
.Property(e => e.Id)
.HasConversion(guidToString);
modelBuilder
.Entity <QuizOptionModel>()
.Property(e => e.Id)
.HasConversion(guidToString);
}
protected override void OnModelCreating(ModelBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
base.OnModelCreating(builder);
builder.ConfigurePersistedGrantContext(_operationalStoreOptions.Value);
builder.Entity <ApplicationUser>()
.HasMany(c => c.CreatedSounds)
.WithOne(e => e.ApplicationUser);
var valueConverter = new GuidToStringConverter();
foreach (var entityType in builder.Model.GetEntityTypes())
{
entityType.GetProperties()
.Where(p => typeof(Guid).IsAssignableFrom(p.ClrType))
.ToList()
.ForEach(p => p.SetValueConverter(valueConverter));
}
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
ValueConverter primaryKeyConverter = null;
if (Database.IsSqlite())
{
primaryKeyConverter = new GuidToStringConverter();
}
modelBuilder.ApplyConfiguration(new RepositoryMap(primaryKeyConverter));
modelBuilder.ApplyConfiguration(new RoleMap(primaryKeyConverter));
modelBuilder.ApplyConfiguration(new TeamMap(primaryKeyConverter));
modelBuilder.ApplyConfiguration(new UserMap(primaryKeyConverter));
modelBuilder.Query <NameDesc>();
modelBuilder.Query <OldRepo>();
modelBuilder.Query <OldUser>();
var builder1 = modelBuilder.Entity <TeamRepository_Permission>();
builder1.Property(x => x.TeamId).HasColumnName("Team_Id").HasConversion(primaryKeyConverter);
builder1.Property(x => x.RepositoryId).HasColumnName("Repository_Id").HasConversion(primaryKeyConverter);
builder1.HasKey(x => new { x.RepositoryId, x.TeamId });
builder1.HasOne(x => x.Repository)
.WithMany(r => r.Teams)
.HasForeignKey(x => x.RepositoryId);
builder1.HasOne(x => x.Team)
.WithMany(t => t.Repositories)
.HasForeignKey(x => x.TeamId);
var builder2 = modelBuilder.Entity <UserRepository_Administrator>();
builder2.Property(x => x.UserId).HasColumnName("User_Id").HasConversion(primaryKeyConverter);
builder2.Property(x => x.RepositoryId).HasColumnName("Repository_Id").HasConversion(primaryKeyConverter);
builder2.HasKey(x => new { x.RepositoryId, x.UserId });
builder2.HasOne(x => x.User)
.WithMany(u => u.AdministratedRepositories)
.HasForeignKey(x => x.UserId);
builder2.HasOne(x => x.Repository)
.WithMany(r => r.Administrators)
.HasForeignKey(x => x.RepositoryId);
var builder3 = modelBuilder.Entity <UserRepository_Permission>();
builder3.Property(x => x.UserId).HasColumnName("User_Id").HasConversion(primaryKeyConverter);
builder3.Property(x => x.RepositoryId).HasColumnName("Repository_Id").HasConversion(primaryKeyConverter);
builder3.HasKey(x => new { x.RepositoryId, x.UserId });
builder3.HasOne(x => x.User)
.WithMany(u => u.Repositories)
.HasForeignKey(x => x.UserId);
builder3.HasOne(x => x.Repository)
.WithMany(r => r.Users)
.HasForeignKey(x => x.RepositoryId);
var builder4 = modelBuilder.Entity <UserRole_InRole>();
builder4.Property(x => x.UserId).HasColumnName("User_Id").HasConversion(primaryKeyConverter);
builder4.Property(x => x.RoleId).HasColumnName("Role_Id").HasConversion(primaryKeyConverter);
builder4.HasKey(x => new { x.RoleId, x.UserId });
builder4.HasOne(x => x.User)
.WithMany(u => u.Roles)
.HasForeignKey(x => x.UserId)
.OnDelete(DeleteBehavior.Cascade);
builder4.HasOne(x => x.Role)
.WithMany(r => r.Users)
.HasForeignKey(x => x.RoleId)
.OnDelete(DeleteBehavior.Cascade);
var builder5 = modelBuilder.Entity <UserTeam_Member>();
builder5.Property(x => x.UserId).HasColumnName("User_Id").HasConversion(primaryKeyConverter);
builder5.Property(x => x.TeamId).HasColumnName("Team_Id").HasConversion(primaryKeyConverter);
builder5.HasKey(x => new { x.TeamId, x.UserId });
builder5.HasOne(x => x.User)
.WithMany(u => u.Teams)
.HasForeignKey(x => x.UserId);
builder5.HasOne(x => x.Team)
.WithMany(t => t.Users)
.HasForeignKey(x => x.TeamId);
}
