internal static async Task <TEntity[]> UpdateEntities <TRequest, TEntity>(this TRequest request,
IRequestConfig config,
IServiceProvider provider,
IEnumerable <Tuple <object, TEntity> > items,
CancellationToken token)
where TRequest : IBulkRequest
where TEntity : class
{
var updator = config.GetUpdatorFor <TEntity>();
var context = new RequestContext <TRequest>
{
Request = request,
ServiceProvider = provider
}.Box();
try
{
var entities = await Task.WhenAll(items.Select(x => updator(context, x.Item1, x.Item2, token))).Configure();
token.ThrowIfCancellationRequested();
return(entities);
}
catch (Exception e) when(IsNonCancellationFailure(e))
{
throw new UpdateEntityFailedException(GenericUpdateEntityError, e)
{
ItemProperty = items.Select(x => x.Item1).ToArray(),
EntityProperty = items.Select(x => x.Item2).ToArray()
};
}
}
internal static async Task RunEntityHooks <TEntity>(this ICrudlessRequest request,
IRequestConfig config,
IServiceProvider provider,
IEnumerable <object> entities,
CancellationToken ct)
where TEntity : class
{
var hooks = config.GetEntityHooksFor <TEntity>(provider);
foreach (var entity in entities)
{
foreach (var hook in hooks)
{
try
{
await hook.Run(request, entity, ct).Configure();
ct.ThrowIfCancellationRequested();
}
catch (Exception e) when(IsNonCancellationFailure(e))
{
throw new HookFailedException(GenericHookError("entity"), e)
{
HookProperty = hook
};
}
}
}
}
internal static async Task <object[]> RunItemHooks <TEntity>(this IBulkRequest request,
IRequestConfig config,
IServiceProvider provider,
object[] items,
CancellationToken ct)
where TEntity : class
{
var hooks = config.GetItemHooksFor <TEntity>(provider);
foreach (var hook in hooks)
{
for (var i = 0; i < items.Length; ++i)
{
try
{
items[i] = await hook.Run(request, items[i], ct).Configure();
ct.ThrowIfCancellationRequested();
}
catch (Exception e) when(IsNonCancellationFailure(e))
{
throw new HookFailedException(GenericHookError("item"), e)
{
HookProperty = hook
};
}
}
}
return(items);
}
internal static async Task <TEntity> UpdateEntity <TRequest, TEntity>(this TRequest request,
IRequestConfig config,
IServiceProvider provider,
object item,
TEntity entity,
CancellationToken token)
where TEntity : class
{
var updator = config.GetUpdatorFor <TEntity>();
var context = new RequestContext <TRequest>
{
Request = request,
ServiceProvider = provider
}.Box();
try
{
entity = await updator(context, item, entity, token).Configure();
token.ThrowIfCancellationRequested();
return(entity);
}
catch (Exception e) when(IsNonCancellationFailure(e))
{
throw new UpdateEntityFailedException(GenericUpdateEntityError, e)
{
ItemProperty = item,
EntityProperty = entity
};
}
}
internal static async Task <T> RunResultHooks <T>(this ICrudlessRequest request,
IRequestConfig config,
IServiceProvider provider,
T result,
CancellationToken ct)
{
var hooks = config.GetResultHooks(provider);
foreach (var hook in hooks)
{
try
{
if (typeof(T).IsAssignableFrom(hook.ResultType))
{
result = (T)await hook.Run(request, result, ct).Configure();
}
else
{
result = await ResultHookAdapter.Adapt(hook, request, result, ct).Configure();
}
ct.ThrowIfCancellationRequested();
}
catch (Exception e) when(IsNonCancellationFailure(e))
{
throw new HookFailedException(GenericHookError("result"), e)
{
HookProperty = hook
};
}
}
return(result);
}
internal static async Task RunAuditHooks <TEntity>(this ICrudlessRequest request,
IRequestConfig config,
IServiceProvider provider,
TEntity oldEntity,
TEntity newEntity,
CancellationToken ct)
where TEntity : class
{
var hooks = config.GetAuditHooksFor <TEntity>(provider);
foreach (var hook in hooks)
{
try
{
await hook.Run(request, oldEntity, newEntity, ct).Configure();
ct.ThrowIfCancellationRequested();
}
catch (Exception e) when(IsNonCancellationFailure(e))
{
throw new HookFailedException(GenericHookError("audit"), e)
{
HookProperty = hook
};
}
}
}
public EntitySet(IEntitySet <TEntity> entitySetImpl, IServiceProvider provider)
{
Implementation = entitySetImpl;
_createAgent = provider.ProvideInstance <ICreateDataAgent>();
_updateAgent = provider.ProvideInstance <IUpdateDataAgent>();
_deleteAgent = provider.ProvideInstance <IDeleteDataAgent>();
_bulkCreateAgent = provider.ProvideInstance <IBulkCreateDataAgent>();
_bulkUpdateAgent = provider.ProvideInstance <IBulkUpdateDataAgent>();
_bulkDeleteAgent = provider.ProvideInstance <IBulkDeleteDataAgent>();
}
public IBoxedSorter GetSorterFor <TEntity>(IServiceProvider provider)
where TEntity : class
{
foreach (var type in typeof(TEntity).BuildTypeHierarchyUp())
{
if (_entitySorters.TryGetValue(type, out var sorter))
{
return(sorter.Create(provider));
}
}
return(null);
}
protected async Task <Response <TResult> > HandleWithErrorsAsync <TResult>(TRequest request,
IServiceProvider provider,
CancellationToken token,
Func <TRequest, IServiceProvider, CancellationToken, Task <TResult> > handleAsync)
{
var result = default(TResult);
try
{
token.ThrowIfCancellationRequested();
try
{
result = await handleAsync(request, provider, token).Configure();
}
catch (AggregateException e)
{
throw Unwrap(e);
}
}
catch (Exception e) when(FailedToFindError.IsReturnedFor(e))
{
return(ErrorDispatcher.Dispatch <TResult>(FailedToFindError.From(request, e)));
}
catch (Exception e) when(RequestFailedError.IsReturnedFor(e))
{
return(ErrorDispatcher.Dispatch <TResult>(RequestFailedError.From(request, e)));
}
catch (Exception e) when(RequestCanceledError.IsReturnedFor(e))
{
return(ErrorDispatcher.Dispatch <TResult>(RequestCanceledError.From(request, e)));
}
catch (Exception e) when(HookFailedError.IsReturnedFor(e))
{
return(ErrorDispatcher.Dispatch <TResult>(HookFailedError.From(request, e)));
}
catch (Exception e) when(CreateEntityFailedError.IsReturnedFor(e))
{
return(ErrorDispatcher.Dispatch <TResult>(CreateEntityFailedError.From(request, e)));
}
catch (Exception e) when(UpdateEntityFailedError.IsReturnedFor(e))
{
return(ErrorDispatcher.Dispatch <TResult>(UpdateEntityFailedError.From(request, e)));
}
catch (Exception e) when(CreateResultFailedError.IsReturnedFor(e))
{
return(ErrorDispatcher.Dispatch <TResult>(CreateResultFailedError.From(request, e)));
}
return(result.AsResponse());
}
public List <IBoxedAuditHook> GetAuditHooksFor <TEntity>(IServiceProvider provider)
where TEntity : class
{
var hooks = new List <IBoxedAuditHook>();
foreach (var type in typeof(TEntity).BuildTypeHierarchyDown())
{
if (_auditHooks.TryGetValue(type, out var auditHooks))
{
hooks.AddRange(auditHooks.GetHooks(provider));
}
}
return(hooks);
}
public List <IBoxedFilter> GetFiltersFor <TEntity>(IServiceProvider provider)
where TEntity : class
{
var filters = new List <IBoxedFilter>();
foreach (var type in typeof(TEntity).BuildTypeHierarchyDown())
{
if (_entityFilters.TryGetValue(type, out var entityFilters))
{
filters.AddRange(entityFilters.GetFilters(provider));
}
}
return(filters);
}
internal static async Task RunRequestHooks(this ICrudlessRequest request,
IRequestConfig config,
IServiceProvider provider,
CancellationToken ct)
{
var hooks = config.GetRequestHooks(provider);
foreach (var hook in hooks)
{
try
{
await hook.Run(request, ct).Configure();
ct.ThrowIfCancellationRequested();
}
catch (Exception e) when(IsNonCancellationFailure(e))
{
throw new HookFailedException(GenericHookError("request"), e)
{
HookProperty = hook
};
}
}
}
public IBoxedSorter Create(IServiceProvider provider) => _adaptedInstance;
public IBoxedRequestHook Create(IServiceProvider provider) => _hook;
public IBoxedRequestHook Create(IServiceProvider provider) => _adaptedInstance;
public List <THook> GetHooks(IServiceProvider provider) => _hookFactories.Select(factory => _hookFactoryCreateFunc(factory, provider)).ToList();
public IBoxedAuditHook Create(IServiceProvider provider) => _hook;
public List <IBoxedResultHook> GetResultHooks(IServiceProvider provider)
{
return(_resultHooks.GetHooks(provider));
}
internal static async Task <TResult[]> CreateResults <TRequest, TEntity, TResult>(this TEntity[] entities,
TRequest request,
IRequestConfig config,
IServiceProvider provider,
CancellationToken token)
where TRequest : ICrudlessRequest
where TEntity : class
{
var createResult = config.GetResultCreatorFor <TEntity, TResult>();
var context = new RequestContext <TRequest>
{
Request = request,
ServiceProvider = provider
}.Box();
try
{
var results = await Task.WhenAll(entities.Select(x => createResult(context, x, token))).Configure();
token.ThrowIfCancellationRequested();
return(results);
}
catch (Exception e) when(IsNonCancellationFailure(e))
{
throw new CreateResultFailedException(GenericCreateResultError, e)
{
EntityProperty = entities
};
}
}
public IBoxedResultHook Create(IServiceProvider provider) => _hookFactory(provider);
public IBoxedEntityHook Create(IServiceProvider provider) => _adaptedInstance;
public IBoxedSorter Create(IServiceProvider provider) => _sorter;
public IBoxedEntityHook Create(IServiceProvider provider) => _hook;
public IBoxedItemHook Create(IServiceProvider provider) => _hook;
internal static async Task RunAuditHooks <TEntity>(this ICrudlessRequest request,
IRequestConfig config,
IServiceProvider provider,
IEnumerable <(TEntity, TEntity)> entities,
public IBoxedFilter Create(IServiceProvider provider) => _filter;
