public async Task <IHttpActionResult> Get(ODataQueryOptions <MintRequest> options, CancellationToken cancellationToken) { var querySettings = new ODataQuerySettings(); using (var circuitBreaker = this.NewCircuitBreaker(cancellationToken)) { var mintRequests = await repository.GetAsync(query => options.ApplyTo(query, querySettings), circuitBreaker.Token); return(this.Success(mintRequests)); } }
public static Task <TResult> GetAsync <T, TResult>(this IReadOnlyRepository <T> repository, Func <IQueryable <T>, TResult> queryShaper) where T : class { Contract.Requires(repository != null); Contract.Requires(queryShaper != null); Contract.Ensures(Contract.Result <Task <TResult> >() != null); return(repository.GetAsync(queryShaper, CancellationToken.None)); }
internal static async Task <IEnumerable <TChild> > SubqueryAsync <TEntity, TChild>( this IReadOnlyRepository <TEntity> repository, Expression <Func <TEntity, bool> > predicate, Expression <Func <TEntity, ICollection <TChild> > > property, CancellationToken cancellationToken) where TEntity : class where TChild : class { if (!(repository is DbContext context)) { return(await repository.GetAsync(q => q.Where( predicate ).Select( property ).SelectMany(i => i), cancellationToken).ConfigureAwait(false)); } var entity = await context.Set <TEntity>().SingleOrDefaultAsync(predicate, cancellationToken).ConfigureAwait(false); if (entity == null) { return(null); } var query = context.Entry(entity).Collection(property).Query(); if (query is IDbAsyncEnumerable <TChild> ) { return(await query.ToArrayAsync(cancellationToken).ConfigureAwait(false)); } return(query); }
private async Task GetAmigo(JogoDto jogo) { if (jogo.AmigoId.HasValue) { jogo.Amigo = ObjectMapper.Map <Amigo, AmigoDto>(await _amigoRepository.GetAsync(jogo.AmigoId.Value)); } }
protected override async Task <bool> OnExecuteStepAsync(IContext context) { bool returnValue = false; // // Get a repository for IEmployeeEntity. //( IReadOnlyRepository <IEmployeeEntity> repository = await this.RepositoryFactory.GetReadOnlyAsync <IEmployeeEntity>(); // // Get the promoted employees. // IEnumerable <IEmployeeEntity> promotedEmployees = await repository.GetAsync(t => t.JobTitle == "Promoted"); // // Display the employee. // this.Logger.LogInformation("These employees have been promoted:"); foreach (var employee in promotedEmployees) { this.Logger.LogInformation($"{employee}"); } // // Since we are using transient lifetimes, we need to dispose. // await repository.TryDisposeAsync(); returnValue = true; return(returnValue); }
public static Task <IEnumerable <T> > FindByAsync <T>(this IReadOnlyRepository <T> repository, Expression <Func <T, bool> > predicate, CancellationToken cancellationToken) where T : class { Contract.Requires(repository != null); Contract.Requires(predicate != null); Contract.Ensures(Contract.Result <Task <IEnumerable <T> > >() != null); return(repository.GetAsync(q => q.Where(predicate), cancellationToken)); }
public static async Task <PagedCollection <T> > PaginateAsync <T>(this IReadOnlyRepository <T> repository, Func <IQueryable <T>, IQueryable <T> > queryShaper, int pageIndex, int pageSize, CancellationToken cancellationToken) where T : class { Contract.Requires(repository != null); Contract.Requires(pageIndex >= 0); Contract.Requires(pageSize >= 1); Contract.Ensures(Contract.Result <Task <PagedCollection <T> > >() != null); var groups = await repository.GetAsync( q => { var query = queryShaper(q); var startIndex = pageIndex *pageSize; return(query.Skip(startIndex) .Take(pageSize) .GroupBy( g => new { Total = query.Count() })); }, cancellationToken); // return first group var result = groups.FirstOrDefault(); if (result == null) { return(new PagedCollection <T>(Enumerable.Empty <T>(), 0L)); } return(new PagedCollection <T>(result, result.Key.Total)); }
public static async Task <T> GetSingleAsync <T>(this IReadOnlyRepository <T> repository, Expression <Func <T, bool> > predicate, CancellationToken cancellationToken) where T : class { Contract.Requires(repository != null); Contract.Requires(predicate != null); Contract.Ensures(Contract.Result <Task <T> >() != null); var items = await repository.GetAsync(q => q.Where(predicate), cancellationToken); return(items.SingleOrDefault()); }
public async Task <IEnumerable <JobsListDto> > FindJobsListAsync(string username) { IEnumerable <JobsListReadItem> jobLists = await _jobsListRepository.GetAsync(x => x.PartitionKey == username); return(jobLists.Select(x => new JobsListDto( x.Id, x.Username, x.Category, x.CreatedTimeUtc !.Value))); }
public async ValueTask <IEnumerable <JobDto> > FindJobsForJobsListAsync(Guid jobListId) { IEnumerable <JobItem> jobs = await _jobsRepository.GetAsync(x => x.PartitionKey == jobListId.ToString()); return(jobs.Select(x => new JobDto( x.Id, x.Title, x.Due, x.CompletedAt))); }
public async Task <IHttpActionResult> Get([FromODataUri] string id, ODataQueryOptions <Token> options, CancellationToken cancellationToken) { var querySettings = new ODataQuerySettings(); using (var circuitBreaker = this.NewCircuitBreaker(cancellationToken)) { var tokens = await repository.GetAsync(query => options.ApplyTo(query.Where(t => t.Id == id), querySettings), circuitBreaker.Token); var token = tokens.SingleOrDefault(); return(this.SuccessOrNotFound(token)); } }
public async Task <IActionResult> Get(Guid?id, CancellationToken cancellationToken = default) { if (id == null) { //IQueryable<User> q = _userRepository.AsQueryable( // new NavigationPropertyTree<User, object> // { // Path = u => u.TenantUsers // } //); //return Ok(q); IQueryable <User> q = _userRepository.AsQueryable() .Select(u => new User { Id = u.Id, Email = u.Email, Name = u.Name, //TenantUsers = u.TenantUsers TenantUsers = u.TenantUsers.Select(tu => new TenantUser { Id = tu.Id, Tenant = tu.Tenant, User = tu.User }).ToImmutableArray() }); return(Ok(q)); //return Ok(await _userRepository.GetAllAsync(null, cancellationToken)); } User user = await _userRepository.GetAsync(id.Value, u => new User { Id = u.Id, Email = u.Email, Name = u.Name }, cancellationToken); if (user == null) { return(NotFound()); } return(Ok(user)); }
public async Task <Result <BucketDocument> > HandleAsync(GetBucketQuery query, CancellationToken cancellationToken = default) { Assert.IsNotNull(query, nameof(query)); cancellationToken.ThrowIfCancellationRequested(); var userId = _userContext.UserId; var bucket = await _readOnlyRepository.GetAsync(p => p.Id == query.Id && p.UserId == userId, cancellationToken); if (bucket is null) { return(Result.Failed <BucketDocument>((int)HttpStatusCode.NotFound, "Bucket not found.")); } var document = _mapperDefinition.Map(bucket); return(Result.Ok(document)); }
internal static async Task <IEnumerable> SubqueryAsync <TEntity, TChild>( this IReadOnlyRepository <TEntity> repository, Expression <Func <TEntity, bool> > predicate, Expression <Func <TEntity, ICollection <TChild> > > property, ODataQueryOptions <TChild> options, CancellationToken cancellationToken) where TEntity : class where TChild : class { if (!(repository is DbContext context)) { var results = await repository.GetAsync(q => options.ApplyTo(q.Where(predicate).Select(property)), cancellationToken).ConfigureAwait(false); return(results.ToArray()); } var entity = await context.Set <TEntity>().SingleOrDefaultAsync(predicate, cancellationToken).ConfigureAwait(false); if (entity == null) { return(null); } var query = context.Entry(entity).Collection(property).Query(); var subquery = options.ApplyTo(query); if (query is IDbAsyncEnumerable <TChild> typedEnumerable) { return(await query.ToArrayAsync(cancellationToken).ConfigureAwait(false)); } else if (query is IDbAsyncEnumerable untypedEnumerable) { var enumerate = asyncEnumerables.GetOrAdd(query.ElementType, NewEnumerator); if (asyncEnumerables.Count > 100) { asyncEnumerables.Clear(); } return(await enumerate(untypedEnumerable, cancellationToken).ConfigureAwait(false)); } return(subquery.ToArray()); }
public override async Task OnConnectedAsync() { if (CurrentUser.Id != null) { var currentUser = await AppUserRepository.GetAsync(CurrentUser.Id.Value); var mapped = new SmallAppUser { Id = currentUser.Id, DisplayName = currentUser.DisplayName, Picture = currentUser.Picture, ConnectionId = Context.ConnectionId }; await GeneralRoomAdd(mapped); UserConnecteds.Add(mapped); } await base.OnConnectedAsync(); }
public async Task <IEnumerable <int> > ExecuteSelectionAsync() { IEnumerable <int> returnValue = Array.Empty <int>(); // // Get a repository for IEmployeeEntity. // IReadOnlyRepository <IEmployeeEntity> repository = await this.RepositoryFactory.GetReadOnlyAsync <IEmployeeEntity>(); // // Get all active employees ID's. // returnValue = (await repository.GetAsync(t => t.Active)).Select(t => t.Id); // // Since we are using transient lifetimes, we need to dispose. // await repository.TryDisposeAsync(); return(returnValue); }
public async Task <IEmployeeEntity> ExecuteSelectionAsync(int employeeId) { IEmployeeEntity returnValue = null; // // Get a repository for IEmployeeEntity. // IReadOnlyRepository <IEmployeeEntity> repository = await this.RepositoryFactory.GetReadOnlyAsync <IEmployeeEntity>(); // // Get all active employees ID's. // returnValue = (await repository.GetAsync(t => t.Id == employeeId)).SingleOrDefault(); // // Since we are using transient lifetimes, we need to dispose. // await repository.TryDisposeAsync(); return(returnValue); }
public async Task <IHttpActionResult> Get(ODataQueryOptions <Receipt> options) => this.Success(await repository.GetAsync(q => options.ApplyTo(q)));
public virtual Task <TEntity> GetAsync(int id, CancellationToken cancellationToken = default(CancellationToken), bool @readonly = false) { return(@readonly ? _readOnlyRepository.GetAsync(id, cancellationToken) : _repository.GetAsync(id, cancellationToken)); }
protected virtual Task <TReadModel> GetModelAsync(TEvent @event, IReadOnlyRepository <TReadModel> repo) { return(repo.GetAsync(@event.AggregateId)); }
public Task <Role> GetByNameAsync(string roleName) { return(_repository.GetAsync(r => r.Name == roleName)); }
public virtual Task <TEntity> GetAsync(int id, CancellationToken cancellationToken = default(CancellationToken)) { return(_readOnlyRepository.GetAsync(id, cancellationToken)); }
public static Task <IEnumerable <T> > GetAllAsync <T>(this IReadOnlyRepository <T> repository) where T : class { Contract.Requires(repository != null); Contract.Ensures(Contract.Result <Task <IEnumerable <T> > >() != null); return(repository.GetAsync(q => q, CancellationToken.None)); }
public async Task <HotelDto> GetHotelAsync(Guid id) { var hotel = await _hotelRepository.GetAsync(id); return(ObjectMapper.Map <Hotel, HotelDto>(hotel)); }