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));
}