public Task <OperationResultOf <TEntity> > TryUpdateAsync(TKey key,
Action <TEntity> updateAction,
CancellationToken cancellationToken = default)
{
return(StoreSessionSafeUsageVisitor.TryUseAsync(async dbSession =>
{
var validationOpRes = KeyEntityValidator.Validate(key);
if (!validationOpRes)
{
return validationOpRes.ErrorMessage.AsFailedOpResOf <TEntity>();
}
var getOpRes = await this.TryGetSingleAsync(key, cancellationToken)
.ConfigureAwait(false);
if (!getOpRes)
{
return getOpRes;
}
var existingEntity = getOpRes.Value;
updateAction(existingEntity);
await dbSession.UpdateAsync(getOpRes.Value, cancellationToken)
.ConfigureAwait(false);
return await SaveChangesAndReturnResultAsync(
dbSession, existingEntity, cancellationToken)
.ConfigureAwait(false);
}));
}
public async Task <OperationResultOf <TEntity> > TryRemoveAsync(TKey key,
CancellationToken cancellationToken = default)
{
var validationOpRes = KeyEntityValidator.Validate(key);
if (!validationOpRes)
{
return(validationOpRes.ErrorMessage.AsFailedOpResOf <TEntity>());
}
var getOpRes = await TryGetSingleAsync(key, cancellationToken)
.ConfigureAwait(false);
if (!getOpRes)
{
return(getOpRes);
}
return(await DbContextSafeUsageVisitor.TryUseAsync(async dbSession =>
{
var foundEntity = getOpRes.Value;
var dbSet = dbSession.Set <TEntity>();
dbSet.Attach(foundEntity);
dbSet.Remove(foundEntity);
return await SaveChangesAndReturnResultAsync(dbSession, foundEntity, cancellationToken)
.ConfigureAwait(false);
}).ConfigureAwait(false));
}
public Task <OperationResultOf <TEntity> > TryGetSingleAsync(TKey key,
CancellationToken cancellation = default,
params Expression <Func <TEntity, object> >[] toBeIncluded)
{
var validationOpRes = KeyEntityValidator.Validate(key);
if (!validationOpRes)
{
return(Task.FromResult(validationOpRes.ErrorMessage.
AsFailedOpResOf <TEntity>()));
}
return(DbContextSafeUsageVisitor.TryUseAsync(dbSession =>
InternalTryGetSingleAsync(dbSession, key,
trackChanges: _trackChangesOnRetrievedEntities,
cancellation,
toBeIncluded)));
}
public Task <OperationResultOf <TEntity> > TryAddAsync(TEntity newEntity,
CancellationToken cancellationToken = default)
{
return(StoreSessionSafeUsageVisitor.TryUseAsync(async dbSession =>
{
var validationOpRes = KeyEntityValidator.Validate(newEntity);
if (!validationOpRes)
{
return validationOpRes.ErrorMessage.AsFailedOpResOf <TEntity>();
}
await dbSession.SaveAsync(dbSession, cancellationToken)
.ConfigureAwait(false);
return await SaveChangesAndReturnResultAsync(dbSession,
newEntity,
cancellationToken)
.ConfigureAwait(false);
}));
}
public Task <OperationResultOf <TEntity> > TryUpdateAsync(TKey key,
Action <TEntity> updateAction,
CancellationToken cancellationToken = default)
{
var validationOpRes = KeyEntityValidator.Validate(key);
if (!validationOpRes)
{
return(Task.FromResult(validationOpRes.ErrorMessage.AsFailedOpResOf <TEntity>()));
}
return(DbContextSafeUsageVisitor.TryUseAsync(async dbSession =>
{
var getOpRes = await InternalTryGetSingleAsync(dbSession, key,
trackChanges: true,
cancellationToken)
.ConfigureAwait(false);
if (!getOpRes)
{
return getOpRes;
}
var targetEntity = getOpRes.Value;
updateAction(targetEntity);
var valueValidationOpRes = KeyEntityValidator.Validate(targetEntity);
if (!valueValidationOpRes)
{
return valueValidationOpRes.ErrorMessage.AsFailedOpResOf <TEntity>();
}
return await SaveChangesAndReturnResultAsync(dbSession, targetEntity, cancellationToken)
.ConfigureAwait(false);
}));
}
