/// <inheritdoc cref="RepositoryBase{TEntity,TDbContext}.CreateAsync(TEntity)"/> public override async Task <(bool success, Guid id)> CreateAsync(TrainingSession entity) { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); bool saveSuccess; try { EntityValidator.Validate(entity); DbContext.Entry(entity.TrainingRoom).State = EntityState.Unchanged; DbContext.Set <TrainingSession>().Add(entity); int saveResult = await DbContext.SaveChangesAsync(); // Force the DbContext to fetch the species anew on next query. foreach (TrainingSession session in entity.TrainingRoom.TrainingSessions) { DbContext.Entry(session).State = EntityState.Detached; } saveSuccess = Convert.ToBoolean(saveResult); } catch (Exception ex) { CreatingEntityFailedException creatingEntityFailedException = new CreatingEntityFailedException($"The entity of type {typeof(TrainingSession).Name} could not be created.", ex); Logger.LogError(creatingEntityFailedException, creatingEntityFailedException.Message); throw creatingEntityFailedException; } return(success : saveSuccess, id : entity.Id); }
private static bool GetValue(Type entityType, object entity, PropertyInfo property, dynamic dto) { string propertyTypeName = property.PropertyType.Name.Replace("Proxy", "").Replace("Dto", ""); // TODO: Verify if the current "Entity" type has a DTO type. if not throw! // TODO: also check if the property name is not equal to an Entity by chance... so maybe try to check for standard types? if (!typeof(UserDto).Assembly.GetTypes().Any(t => t.Name.Equals(propertyTypeName + "Dto"))) { return(false); } Type newEntityType = typeof(User).Assembly.GetTypes().First(t => t.Name.Equals(propertyTypeName)); object entityObject; // NOTE: Because of lazy loading the database will need to be locked to ensure no parallel queries are running (which will throw errors). // This will use the shared globally shared LoadLock. if (property.PropertyType.Name.Contains("Proxy")) { using EntityLoadLock.Releaser lazyLoadLock = EntityLoadLock.Shared.Lock(); entityObject = entityType.GetProperty(property.Name)?.GetValue(entity, null); } else { entityObject = entityType.GetProperty(property.Name)?.GetValue(entity, null); } if (entityObject == null) { return(false); } object result = Convert(property.PropertyType, newEntityType, entityObject); property.SetValue(dto, result); return(true); }
/// <inheritdoc cref="IRepository{TEntity}.DeleteAsync(TEntity)"/> public virtual async Task <bool> DeleteAsync(TEntity entity) { bool saveSuccess = false; using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); try { if (!await DbContext.Set <TEntity>().ContainsAsync(entity)) { throw new EntityNotFoundException($"The entity of type {typeof(TEntity).Name} could not be found."); } DbContext.Set <TEntity>().Remove(entity); int saveResult = await DbContext.SaveChangesAsync(); saveSuccess = Convert.ToBoolean(saveResult); } catch (Exception ex) { DeletingEntityFailedException deletingEntityFailedException = new DeletingEntityFailedException($"The entity of type {typeof(TEntity).Name} could not be deleted.", ex); Logger.LogError(deletingEntityFailedException, deletingEntityFailedException.Message); throw deletingEntityFailedException; } return(saveSuccess); }
/// <inheritdoc cref="ITrainingSessionRepository.InsertFirstGenerationAsync(TrainingSession)"/> public async Task InsertFirstGenerationAsync(TrainingSession trainingSession) { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); try { foreach (Species species in trainingSession.TrainingRoom.Species.Where(species => DbContext.Entry(species).State != EntityState.Unchanged)) { MarkSpeciesAsAdded(species); } foreach (LeasedOrganism leasedOrganism in trainingSession.LeasedOrganisms) { DbContext.Entry(leasedOrganism).State = EntityState.Added; } await DbContext.SaveChangesAsync(); DbContext.Update(trainingSession.TrainingRoom); await DbContext.SaveChangesAsync(); } catch (Exception ex) { Logger.LogError(ex, ex.Message); throw; } }
/// <inheritdoc cref="RepositoryBase{TEntity,TDbContext}.FindSingleByExpressionAsync"/> public override async Task <TrainingSession> FindSingleByExpressionAsync(Expression <Func <TrainingSession, bool> > predicate) { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); TrainingSession entity = await TrainingSessionSetWithInclude().Where(predicate).SingleOrDefaultAsync(); if (entity == default) { Console.WriteLine(new EntityNotFoundException($"The entity of type {typeof(TrainingSession).Name} could not be found by the predicate.")); } return(entity); }
/// <inheritdoc cref="IRepository{TEntity}.FindSingleByExpressionAsync(Expression{Func{TEntity, bool}})"/> public virtual async Task <TEntity> FindSingleByExpressionAsync(Expression <Func <TEntity, bool> > predicate) { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); TEntity entity = await DbContext.Set <TEntity>().SingleOrDefaultAsync(predicate); if (entity == default) { Console.WriteLine(new EntityNotFoundException($"The entity of type {typeof(TEntity).Name} could not be found by the predicate.")); } return(entity); }
/// <inheritdoc cref="ITrainingSessionRepository.UpdateOrganismsAsync(TrainingSession)"/> public async Task UpdateOrganismsAsync(TrainingSession trainingSession) { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); try { foreach (Species species in trainingSession.TrainingRoom.Species) { Logger.LogInformation($"{species.GetType()} -> {DbContext.Entry(species).State} | Organisms: {species.Organisms.Count}"); if (DbContext.Entry(species).State == EntityState.Detached) { MarkSpeciesAsAdded(species); continue; } foreach (Organism organism in species.Organisms) { bool newGenes = false; foreach (ConnectionGene connectionGene in organism.ConnectionGenes) { if (DbContext.Entry(connectionGene).State != EntityState.Added) { continue; } newGenes = true; break; } if (newGenes) { DbContext.Entry(organism).State = EntityState.Added; } } } foreach (EntityEntry entityEntry in DbContext.ChangeTracker.Entries() .Where(e => e.State == EntityState.Modified && (e.Entity.GetType() == typeof(InputNode) || e.Entity.GetType() == typeof(OutputNode)))) { DbContext.Entry(entityEntry.Entity).State = EntityState.Added; } await DbContext.SaveChangesAsync(); } catch (DbUpdateException ex) { Logger.LogError(ex, ex.Message); throw; } }
/// <inheritdoc cref="IRepository{TEntity, TId}.ExistsAsync(Expression{Func{TEntity, bool}})"/> public async Task <bool> SaveChangesAsync() { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); bool saveSuccess = false; try { int saveResult = await DbContext.SaveChangesAsync(); saveSuccess = Convert.ToBoolean(saveResult); } catch (Exception ex) { SavingChangesFailedException exception = new SavingChangesFailedException("The changes failed to save.", ex); Logger.Log(LogLevel.Error, exception, exception.Message); } return(saveSuccess); }
/// <inheritdoc cref="IRepository{TEntity}.UpdateAsync(TEntity)"/> public virtual async Task <bool> UpdateAsync(TEntity entity) { bool saveSuccess = false; using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); DbContext.Update(entity); try { int saveResult = await DbContext.SaveChangesAsync(); saveSuccess = Convert.ToBoolean(saveResult); } catch (Exception ex) { Console.WriteLine(new UpdatingEntityFailedException($"The entity of type {typeof(TEntity).Name} failed to update.", ex)); } return(saveSuccess); }
/// <inheritdoc cref="IRepository{TEntity}.CreateAsync(TEntity)"/> public virtual async Task <bool> CreateAsync(TEntity entity) { bool saveSuccess = false; using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); try { EntityValidator.Validate(entity); DbContext.Set <TEntity>().Add(entity); int saveResult = await DbContext.SaveChangesAsync(); saveSuccess = Convert.ToBoolean(saveResult); } catch (Exception ex) { Console.WriteLine(new CreatingEntityFailedException($"The entity of type {typeof(TEntity).Name} could not be created.", ex)); } return(saveSuccess); }
/// <inheritdoc cref="IRepository{TEntity, TId}.UpdateAsync(TEntity)"/> public virtual async Task <(bool success, TId id, bool updated)> UpdateAsync(TEntity entity) { bool saveSuccess = false; using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); EntityEntry <TEntity> entry = DbContext.Update(entity); try { int saveResult = await DbContext.SaveChangesAsync(); saveSuccess = Convert.ToBoolean(saveResult); } catch (Exception ex) { UpdatingEntityFailedException exception = new UpdatingEntityFailedException($"The entity of type {typeof(TEntity).Name} failed to update.", ex); Logger.Log(LogLevel.Error, exception, exception.Message); } return(success : saveSuccess, id : entity.Id, updated : entry.State == EntityState.Modified); }
/// <inheritdoc cref="IRepository{TEntity, TId}.CreateAsync(TEntity)"/> public virtual async Task <(bool success, TId id)> CreateAsync(TEntity entity) { bool saveSuccess = false; using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); try { EntityValidator.Validate(entity); DbContext.Set <TEntity>().Add(entity); int saveResult = await DbContext.SaveChangesAsync(); saveSuccess = Convert.ToBoolean(saveResult); } catch (Exception ex) { CreatingEntityFailedException exception = new CreatingEntityFailedException($"The entity of type {typeof(TEntity).Name} could not be created.", ex); Logger.Log(LogLevel.Error, exception, exception.Message); } return(success : saveSuccess, id : entity.Id); }
/// <inheritdoc cref="RepositoryBase{TEntity,TDbContext}.CreateAsync(TEntity)"/> public override async Task <(bool success, Guid id)> CreateAsync(TrainingRoom entity) { bool saveSuccess = false; using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); try { EntityValidator.Validate(entity); DbContext.Entry(entity.Owner).State = EntityState.Unchanged; DbContext.Set <TrainingRoom>().Add(entity); int saveResult = await DbContext.SaveChangesAsync(); saveSuccess = Convert.ToBoolean(saveResult); } catch (Exception ex) { CreatingEntityFailedException creatingEntityFailedException = new CreatingEntityFailedException($"The entity of type {typeof(TrainingRoom).Name} could not be created.", ex); Logger.LogError(creatingEntityFailedException, creatingEntityFailedException.Message); } return(saveSuccess, entity.Id); }
/// <inheritdoc cref="RepositoryBase{TEntity,TDbContext}.CreateAsync(TEntity)"/> public override async Task <bool> CreateAsync(TrainingRoom entity) { bool saveSuccess = false; using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); try { DbContext.Entry(entity.Owner).State = EntityState.Unchanged; EntityValidator.Validate(entity); DbContext.Set <TrainingRoom>().Add(entity); int saveResult = await DbContext.SaveChangesAsync(); saveSuccess = Convert.ToBoolean(saveResult); } catch (Exception ex) { Console.WriteLine(new CreatingEntityFailedException($"The entity of type {typeof(TrainingRoom).Name} could not be created.", ex)); } return(saveSuccess); }
/// <inheritdoc cref="RepositoryBase{TEntity,TDbContext}.UpdateAsync(TEntity)"/> public override async Task <bool> UpdateAsync(TrainingSession entity) { bool saveSuccess = false; using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); DbContext.Update(entity); try { int saveResult = await DbContext.SaveChangesAsync(); // Force the DbContext to fetch the species anew on next query. foreach (Species species in entity.TrainingRoom.Species) { DbContext.Entry(species).State = EntityState.Detached; } saveSuccess = Convert.ToBoolean(saveResult); } catch (Exception ex) { Console.WriteLine(new UpdatingEntityFailedException($"The entity of type {typeof(TrainingSession).Name} failed to update.", ex)); } return(saveSuccess); }
/// <inheritdoc cref="RepositoryBase{TEntity,TDbContext}.FindManyByExpressionAsync"/> public override async Task <IEnumerable <TrainingRoom> > FindManyByExpressionAsync(Expression <Func <TrainingRoom, bool> > predicate) { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); return(await TrainingRoomSetWithInclude().Where(predicate).ToListAsync()); }
/// <inheritdoc cref="IRepository{TEntity, TId}.GetPaginationAsync(int, int)"/> public virtual async Task <IEnumerable <TEntity> > GetPaginationAsync(int pageNumber, int pageSize) { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); return(await DbContext.Set <TEntity>().Skip(pageNumber * pageSize).Take(pageSize).ToListAsync()); }
/// <inheritdoc cref="IRepository{TEntity}.FindManyByExpressionAsync(Expression{Func{TEntity, bool}})"/> public virtual async Task <IEnumerable <TEntity> > FindManyByExpressionAsync(Expression <Func <TEntity, bool> > predicate) { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); return(await DbContext.Set <TEntity>().Where(predicate).ToListAsync()); }
/// <inheritdoc cref="IRepository{TEntity}.ExistsAsync(Expression{Func{TEntity, bool}})"/> public virtual async Task <bool> ExistsAsync(Expression <Func <TEntity, bool> > predicate) { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); return(await DbContext.Set <TEntity>().AnyAsync(predicate)); }
/// <inheritdoc cref="RepositoryBase{TEntity,TDbContext}.GetAllAsync"/> public override async Task <IEnumerable <TrainingRoom> > GetAllAsync() { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); return(await TrainingRoomSetWithInclude().ToListAsync()); }
/// <inheritdoc cref="IRepository{TEntity}.GetAllAsync"/> public virtual async Task <IEnumerable <TEntity> > GetAllAsync() { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); return(await DbContext.Set <TEntity>().ToListAsync()); }
/// <inheritdoc cref="IRepository{TEntity}.FindSingleOrDefaultAsync(Expression{Func{TEntity, bool}})"/> public virtual async Task <TEntity> FindSingleOrDefaultAsync(Expression <Func <TEntity, bool> > predicate) { using EntityLoadLock.Releaser loadLock = EntityLoadLock.Shared.Lock(); return(await DbContext.Set <TEntity>().SingleOrDefaultAsync(predicate)); }