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;