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