public virtual Task <FindResults <T> > GetByProjectIdAsync(string projectId, CommandOptionsDescriptor <T> options = null) { if (String.IsNullOrEmpty(projectId)) { throw new ArgumentNullException(nameof(projectId)); } return(FindAsync(q => q.Project(projectId), options)); }
public static ICommandOptions Configure(this CommandOptionsDescriptor configure) { ICommandOptions o = new CommandOptions(); if (configure != null) { o = configure(o); } return(o); }
public Task <FindResults <Employee> > GetAllByCompanyAsync(string company, CommandOptionsDescriptor <Employee> options = null) { var commandOptions = options.Configure(); if (commandOptions.ShouldUseCache()) { commandOptions.CacheKey(company); } return(FindAsync(q => q.Company(company), o => commandOptions)); }
public static ICommandOptions <T> Configure <T>(this CommandOptionsDescriptor <T> configure) where T : class { ICommandOptions <T> o = new CommandOptions <T>(); if (configure != null) { o = configure(o); } return(o); }
public Task <FindResults <Organization> > GetByCriteriaAsync(string criteria, CommandOptionsDescriptor <Organization> options, OrganizationSortBy sortBy, bool?paid = null, bool?suspended = null) { var filter = Query <Organization> .MatchAll(); if (!String.IsNullOrWhiteSpace(criteria)) { filter &= Query <Organization> .Term(o => o.Name, criteria); } if (paid.HasValue) { if (paid.Value) { filter &= !Query <Organization> .Term(o => o.PlanId, _plans.FreePlan.Id); } else { filter &= Query <Organization> .Term(o => o.PlanId, _plans.FreePlan.Id); } } if (suspended.HasValue) { if (suspended.Value) { filter &= (!Query <Organization> .Term(o => o.BillingStatus, BillingStatus.Active) && !Query <Organization> .Term(o => o.BillingStatus, BillingStatus.Trialing) && !Query <Organization> .Term(o => o.BillingStatus, BillingStatus.Canceled) ) || Query <Organization> .Term(o => o.IsSuspended, true); } else { filter &= ( Query <Organization> .Term(o => o.BillingStatus, BillingStatus.Active) && Query <Organization> .Term(o => o.BillingStatus, BillingStatus.Trialing) && Query <Organization> .Term(o => o.BillingStatus, BillingStatus.Canceled) ) || Query <Organization> .Term(o => o.IsSuspended, false); } } var query = new RepositoryQuery <Organization>().ElasticFilter(filter); switch (sortBy) { case OrganizationSortBy.Newest: query.SortDescending((Organization o) => o.Id); break; case OrganizationSortBy.Subscribed: query.SortDescending((Organization o) => o.SubscribeDate); break; // case OrganizationSortBy.MostActive: // query.WithSortDescending((Organization o) => o.TotalEventCount); // break; default: query.SortAscending(o => o.Name.Suffix("keyword")); break; } return(FindAsync(q => query, options)); }
public virtual Task <FindResults <T> > GetByOrganizationIdAsync(string organizationId, CommandOptionsDescriptor <T> options = null) { if (String.IsNullOrEmpty(organizationId)) { throw new ArgumentNullException(nameof(organizationId)); } var commandOptions = options.Configure(); if (commandOptions.ShouldUseCache()) { throw new Exception("Caching of paged queries is not allowed"); } return(FindAsync(new RepositoryQuery <T>().Organization(organizationId), commandOptions)); }
public Task <FindResults <Stack> > GetByFilterAsync(ExceptionlessSystemFilter systemFilter, string userFilter, string sort, string field, DateTime utcStart, DateTime utcEnd, CommandOptionsDescriptor <Stack> options = null) { IRepositoryQuery <Stack> query = new RepositoryQuery <Stack>() .DateRange(utcStart, utcEnd, field ?? ElasticType.GetFieldName(s => s.LastOccurrence)) .SystemFilter(systemFilter) .FilterExpression(userFilter); query = !String.IsNullOrEmpty(sort) ? query.SortExpression(sort) : query.SortDescending(s => s.LastOccurrence); return(FindAsync(q => query, options)); }
public static Task <IReadOnlyCollection <T> > GetByIdsAsync <T>(this IReadOnlyRepository <T> repository, Ids ids, CommandOptionsDescriptor <T> options = null) where T : class, new() { return(repository.GetByIdsAsync(ids, options.Configure())); }
public static Task InvalidateCacheAsync <T>(this IReadOnlyRepository <T> repository, IEnumerable <T> documents, CommandOptionsDescriptor <T> options = null) where T : class, new() { return(repository.InvalidateCacheAsync(documents, options.Configure())); }
public Task <long> RemoveAllByUserIdAsync(string userId, CommandOptionsDescriptor <Token> options = null) { return(RemoveAllAsync(q => q.ElasticFilter(Query <Token> .Term(t => t.UserId, userId)), options)); }
public Task <FindResults <T> > FindAsync(RepositoryQueryDescriptor <T> query, CommandOptionsDescriptor <T> options = null) { return(FindAsAsync <T>(query.Configure(), options.Configure())); }
public virtual Task <FindResults <T> > GetByProjectIdAsync(string projectId, CommandOptionsDescriptor <T> options = null) { return(FindAsync(q => q.Project(projectId), options)); }
public Task <FindResults <Stack> > GetExpiredSnoozedStatuses(DateTime utcNow, CommandOptionsDescriptor <Stack> options = null) { return(FindAsync(q => q.ElasticFilter(Query <Stack> .DateRange(d => d.Field(f => f.SnoozeUntilUtc).LessThanOrEquals(utcNow))), options)); }
public Task <FindResults <Stack> > GetIdsByQueryAsync(RepositoryQueryDescriptor <Stack> query, CommandOptionsDescriptor <Stack> options = null) { return(FindAsync(q => query.Configure().OnlyIds(), options)); }
public Task <FindResults <Project> > GetByFilterAsync(AppFilter systemFilter, string userFilter, string sort, CommandOptionsDescriptor <Project> options = null) { IRepositoryQuery <Project> query = new RepositoryQuery <Project>() .AppFilter(systemFilter) .FilterExpression(userFilter); query = !String.IsNullOrEmpty(sort) ? query.SortExpression(sort) : query.SortAscending(p => p.Name.Suffix("keyword")); return(FindAsync(q => query, options)); }
public Task <FindResults <Token> > GetByTypeAndProjectIdAsync(TokenType type, string projectId, CommandOptionsDescriptor <Token> options = null) { var filter = ( Query <Token> .Term(t => t.ProjectId, projectId) || Query <Token> .Term(t => t.DefaultProjectId, projectId) ) && Query <Token> .Term(t => t.Type, type); return(FindAsync(q => q.ElasticFilter(filter), options)); }
public override Task <FindResults <Token> > GetByProjectIdAsync(string projectId, CommandOptionsDescriptor <Token> options = null) { var filter = (Query <Token> .Term(t => t.ProjectId, projectId) || Query <Token> .Term(t => t.DefaultProjectId, projectId)); return(FindAsync(q => q.ElasticFilter(filter), options)); }
public Task <CountResult> CountAsync(RepositoryQueryDescriptor <T> query, CommandOptionsDescriptor <T> options = null) { return(CountAsync(query.Configure(), options.Configure())); }
public Task <FindResults <Child> > QueryAsync(RepositoryQueryDescriptor <Child> query, CommandOptionsDescriptor <Child> options = null) { return(FindAsync(query, options)); }
public Task <FindResults <TResult> > FindAsAsync <TResult>(RepositoryQueryDescriptor <T> query, CommandOptionsDescriptor <T> options = null) where TResult : class, new() { return(FindAsAsync <TResult>(query.Configure(), options.Configure())); }
public static Task <long> CountAsync <T>(this IReadOnlyRepository <T> repository, CommandOptionsDescriptor <T> options = null) where T : class, new() { return(repository.CountAsync(options.Configure())); }
public override Task <FindResults <PersistentEvent> > GetByOrganizationIdAsync(string organizationId, CommandOptionsDescriptor <PersistentEvent> options = null) { if (String.IsNullOrEmpty(organizationId)) { throw new ArgumentNullException(nameof(organizationId)); } return(FindAsync(q => q.Organization(organizationId).SortDescending(e => e.Date).SortDescending(e => e.Id), options)); }
public static Task <FindResults <T> > GetAllAsync <T>(this IReadOnlyRepository <T> repository, CommandOptionsDescriptor <T> options = null) where T : class, new() { return(repository.GetAllAsync(options.Configure())); }
public override Task <FindResults <PersistentEvent> > GetByProjectIdAsync(string projectId, CommandOptionsDescriptor <PersistentEvent> options = null) { return(FindAsync(q => q.Project(projectId).SortDescending(e => e.Date).SortDescending(e => e.Id), options)); }
public Task<FindResults<User>> GetByOrganizationIdAsync(string organizationId, CommandOptionsDescriptor<User> options = null) { if (String.IsNullOrEmpty(organizationId)) return Task.FromResult<FindResults<User>>(new FindResults<User>()); var commandOptions = options.Configure(); if (commandOptions.ShouldUseCache()) throw new Exception("Caching of paged queries is not allowed"); var filter = Query<User>.Term(u => u.OrganizationIds, organizationId); return FindAsync(q => q.ElasticFilter(filter).SortAscending(u => u.EmailAddress.Suffix("keyword")), o => commandOptions); }
// TODO: We need to index and search by the created time. public Task <FindResults <PersistentEvent> > GetOpenSessionsAsync(DateTime createdBeforeUtc, CommandOptionsDescriptor <PersistentEvent> options = null) { var filter = Query <PersistentEvent> .Term(e => e.Type, Event.KnownTypes.Session) && !Query <PersistentEvent> .Exists(f => f.Field(e => e.Idx[Event.KnownDataKeys.SessionEnd + "-d"])); if (createdBeforeUtc.Ticks > 0) { filter &= Query <PersistentEvent> .DateRange(r => r.Field(e => e.Date).LessThanOrEquals(createdBeforeUtc)); } return(FindAsync(q => q.ElasticFilter(filter).SortDescending(e => e.Date), options)); }
public Task <FindResults <Organization> > GetByRetentionDaysEnabledAsync(CommandOptionsDescriptor <Organization> options = null) { var filter = Query <Organization> .Range(f => f.Field(o => o.RetentionDays).GreaterThan(0)); return(FindAsync(q => q.ElasticFilter(filter).Include(o => o.Id, o => o.Name, o => o.RetentionDays), options)); }
public Task <FindResults <Token> > GetByTypeAndUserIdAsync(TokenType type, string userId, CommandOptionsDescriptor <Token> options = null) { var filter = Query <Token> .Term(e => e.UserId, userId) && Query <Token> .Term(t => t.Type, type); return(FindAsync(q => q.ElasticFilter(filter), options)); }
public Task <FindResults <Project> > GetByOrganizationIdsAsync(ICollection <string> organizationIds, CommandOptionsDescriptor <Project> options = null) { if (organizationIds == null) { throw new ArgumentNullException(nameof(organizationIds)); } if (organizationIds.Count == 0) { return(Task.FromResult(new FindResults <Project>())); } return(FindAsync(q => q.Organizations(organizationIds), options)); }
public Task <FindResults <Token> > GetByTypeAndOrganizationIdAsync(TokenType type, string organizationId, CommandOptionsDescriptor <Token> options = null) { return(FindAsync(q => q.Organization(organizationId).ElasticFilter(Query <Token> .Term(t => t.Type, type)), options)); }