public virtual async Task <TOutput> SaveUpdatedWithOptimisticConcurrencyAsync <TOutput>(IHasRowVersion source, T destination, IPrincipal principal, Action <string, string> writeError, IDataAccessStrategy <T> savingStrategy = default)
{
savingStrategy = savingStrategy ?? dataAccessStrategy;
savingStrategy.ThrowIfNull(nameof(savingStrategy));
TOutput result = default;
if (savingStrategy.CanUpdate(destination))
{
if (savingStrategy.CanUpdateAllProperties(destination))
{
mapper.Map(source, destination);
}
else
{
var properties = savingStrategy.GetPropertiesForUpdate(destination);
UpdateWithIncludeOrExcludeProperties(source, destination, true, properties);
}
bool success = await SaveUpdatedWithOptimisticConcurrencyAsync(destination, writeError, false);
if (success)
{
result = mapper.Map <TOutput>(destination);
}
}
else
{
writeError("", Resources.ErrorMessages.AccessDenied);
}
return(result);
}
public virtual Task <bool> SaveUpdatedWithOptimisticConcurrencyAsync(T entity, IPrincipal principal, Action <string, string> writeError, IDataAccessStrategy <T> savingStrategy = default)
{
savingStrategy = savingStrategy ?? dataAccessStrategy;
savingStrategy.ThrowIfNull(nameof(savingStrategy));
Task <bool> result;
if (savingStrategy.CanUpdate(entity))
{
if (savingStrategy.CanUpdateAllProperties(entity))
{
Update(entity);
}
else
{
var properties = savingStrategy.GetPropertiesForUpdate(entity);
UpdateWithIncludeOrExcludeProperties(entity, true, properties);
}
result = SaveUpdatedWithOptimisticConcurrencyAsync(entity, writeError, false);
}
else
{
writeError("", Resources.ErrorMessages.AccessDenied);
result = Task.FromResult(false);
}
return(result);
}
public virtual Task <bool> DeleteAndCommitWithOptimisticConcurrencyAsync(T entity, IPrincipal principal, Action <string, string> writeError, IDataAccessStrategy <T> savingStrategy = default)
{
savingStrategy = savingStrategy ?? dataAccessStrategy;
savingStrategy.ThrowIfNull(nameof(savingStrategy));
Task <bool> result;
if (!savingStrategy.CanDelete(entity))
{
writeError("", Resources.ErrorMessages.AccessDenied);
result = Task.FromResult(false);
}
else
{
result = DeleteAndCommitWithOptimisticConcurrencyAsync(entity, writeError);
}
return(result);
}
public async Task <bool> SaveNewAsync <TInput>(TInput input, IPrincipal principal, IDataAccessStrategy <T> savingStrategy = default, params object[] args)
{
savingStrategy = savingStrategy ?? dataAccessStrategy;
savingStrategy.ThrowIfNull(nameof(savingStrategy));
bool result = false;
args = args.Concat(input);
bool canAdd = await savingStrategy.CanAdd(args);
if (canAdd)
{
savingStrategy.PrepareForAdd(args);
await SaveNewAsync(input); //I tak EF nie obsługuje operacji równoległych
result = true;
}
return(result);
}
