public async Task UpdateEntityType(params EntityTypeUpdateModel[] models)
{
if (models == null || !models.Any())
{
return;
}
Dictionary <Guid, EntityType> groupDictionary = databaseContext.Set <EntityType>()
.AsNoTracking()
.ToDictionary(x => x.Id);
IList <EntityType> entitiesToUpdate = new List <EntityType>();
foreach (EntityTypeUpdateModel model in models)
{
if (model == null || !groupDictionary.TryGetValue(model.Id, out EntityType entity))
{
continue;
}
entitiesToUpdate.Add(UpdateEntity(entity, model));
}
this.databaseContext.AddRange(entitiesToUpdate);
await this.databaseContext.SaveChangesAsync().ConfigureAwait(false);
}
public async Task UpdateDetails(Guid memoryBookUniverseId, params DetailUpdateModel[] models)
{
if (models == null || !models.Any())
{
return;
}
Dictionary <Guid, Detail> groupDictionary = databaseContext.Set <Detail>()
.Where(x => x.Creator.MemoryBookUniverseId == memoryBookUniverseId)
.AsNoTracking()
.ToDictionary(x => x.Id);
IList <Detail> entitiesToUpdate = new List <Detail>();
foreach (DetailUpdateModel model in models)
{
if (model == null || !groupDictionary.TryGetValue(model.Id, out Detail entity))
{
continue;
}
entitiesToUpdate.Add(UpdateEntity(entity, model));
}
this.databaseContext.AddRange(entitiesToUpdate);
await this.databaseContext.SaveChangesAsync().ConfigureAwait(false);
}
public async Task <IList <RelationshipTypeReadModel> > GetAllRelationshipTypes()
{
return(await databaseContext.Set <RelationshipType>()
.AsNoTracking()
.Select(x => x.ToReadModel())
.ToListAsync());
}
public async Task <IList <MemoryBookUniverseReadModel> > GetAllMemoryBookUniverses()
{
return(await databaseContext.Set <MemoryBookUniverse>()
.AsNoTracking()
.Select(x => x.ToReadModel())
.ToListAsync());
}
public async Task UpdateGroups(Guid memoryBookUniverseId, params GroupUpdateModel[] models)
{
if (models == null || !models.Any())
{
return;
}
var groupDictionary = databaseContext.Set <Group>()
.Where(x => x.MemoryBookUniverseId == memoryBookUniverseId)
.AsNoTracking()
.ToDictionary(x => x.Id);
IList <Group> entitiesToUpdate = new List <Group>();
foreach (var model in models)
{
if (model == null || !groupDictionary.TryGetValue(model.Id, out var entity))
{
continue;
}
entity.Name = model.Name;
entity.Code = model.Code;
entity.Description = model.Description;
entitiesToUpdate.Add(entity);
}
this.databaseContext.AddRange(entitiesToUpdate);
await this.databaseContext.SaveChangesAsync().ConfigureAwait(false);
}
public async Task <IList <RelationshipMembershipReadModel> > GetAllRelationshipMemberships(Guid memoryBookUniverseId)
{
return(await databaseContext.Set <RelationshipMembership>()
.Where(x => x.Relationship.MemoryBookUniverseId == memoryBookUniverseId)
.Include(x => x.Relationship)
.Include(x => x.Member)
.Include(x => x.MemberRelationshipType)
.AsNoTracking()
.Select(x => x.ToReadModel())
.ToListAsync());
}
public async Task <IList <DetailAssociationReadModel> > GetDetailAssociationByDetailId(params Guid[] detailIds)
{
if (detailIds == null || detailIds.Length == 0)
{
return(new List <DetailAssociationReadModel>());
}
return(await databaseContext.Set <DetailAssociation>()
.AsNoTracking()
.Include(x => x.Detail)
.Include(x => x.EntityType)
.Where(x => detailIds.Contains(x.Id))
.Select(x => x.ToReadModel())
.ToListAsync());
}
public async Task DeleteMemoryBookUniverse(params Guid[] memoryBookUniverseIds)
{
if (memoryBookUniverseIds == null || !memoryBookUniverseIds.Any())
{
return;
}
Dictionary <Guid, MemoryBookUniverse> universeDictionary = databaseContext.Set <MemoryBookUniverse>()
.AsNoTracking()
.ToDictionary(x => x.Id);
IList <MemoryBookUniverse> entitiesToDelete = new List <MemoryBookUniverse>();
foreach (Guid id in memoryBookUniverseIds)
{
if (!universeDictionary.TryGetValue(id, out MemoryBookUniverse entity))
{
continue;
}
entitiesToDelete.Add(entity);
}
this.databaseContext.RemoveRange(entitiesToDelete);
await this.databaseContext.SaveChangesAsync().ConfigureAwait(false);
}
private IQueryable <Detail> GetBaseQuery(Guid memoryBookUniverseId)
{
return(databaseContext.Set <Detail>()
.AsNoTracking()
.Include(x => x.DetailType)
.Include(x => x.Permissions)
.Include(x => x.DetailAssociations)
.Where(x => x.Creator == null || x.Creator.MemoryBookUniverseId == memoryBookUniverseId));
}
public async Task DeleteDetailAssociations(params Guid[] detailAssociationIds)
{
if (detailAssociationIds == null || !detailAssociationIds.Any())
{
return;
}
var detailAssociations = await databaseContext.Set <DetailAssociation>()
.Where(x => detailAssociationIds.Contains(x.Id))
.AsNoTracking()
.ToListAsync()
.ConfigureAwait(false);
this.databaseContext.RemoveRange(detailAssociations);
await this.databaseContext.SaveChangesAsync().ConfigureAwait(false);
}
public async Task DeleteGroupMemberships(Guid memoryBookUniverseId, params Guid[] groupMembershipIds)
{
if (groupMembershipIds == null || !groupMembershipIds.Any())
{
return;
}
var groupMemberships = await databaseContext.Set <GroupMembership>()
.Where(x => x.Group.MemoryBookUniverseId == memoryBookUniverseId)
.Where(x => groupMembershipIds.Contains(x.Id))
.AsNoTracking()
.ToListAsync()
.ConfigureAwait(false);
this.databaseContext.RemoveRange(groupMemberships);
await this.databaseContext.SaveChangesAsync().ConfigureAwait(false);
}
public static async Task <ILookup <Guid, Guid> > GetDetailLookup(this MemoryBookDbContext databaseContext, Guid memoryBookUniverseId, EntityTypeEnum entityType)
{
List <DataAccess.Entities.DetailAssociation> groupDetailAssociations = await databaseContext.Set <DataAccess.Entities.DetailAssociation>()
.AsNoTracking()
.Where(x => x.EntityType.Code == entityType.ToString())
.Where(x => x.Detail.Creator.MemoryBookUniverseId == memoryBookUniverseId)
.ToListAsync();
return(groupDetailAssociations.ToLookup(x => x.EntityId, x => x.DetailId));
}
