protected async Task <ActionResult <CountResult> > GetCountImplAsync(AppFilter sf, TimeInfo ti, string filter = null, string aggregations = null)
{
var pr = await _validator.ValidateQueryAsync(filter);
if (!pr.IsValid)
{
return(BadRequest(pr.Message));
}
var far = await _validator.ValidateAggregationsAsync(aggregations);
if (!far.IsValid)
{
return(BadRequest(far.Message));
}
sf.UsesPremiumFeatures = pr.UsesPremiumFeatures || far.UsesPremiumFeatures;
var query = new RepositoryQuery <TModel>()
.AppFilter(ShouldApplySystemFilter(sf, filter) ? sf : null)
.DateRange(ti.Range.UtcStart, ti.Range.UtcEnd, ti.Field)
.Index(ti.Range.UtcStart, ti.Range.UtcEnd);
CountResult result;
try {
result = await _repository.CountAsync(q => q.SystemFilter(query).FilterExpression(filter).AggregationsExpression(aggregations));
} catch (Exception ex) {
using (_logger.BeginScope(new ExceptionlessState().Property("Search Filter", new { SystemFilter = sf, UserFilter = filter, Time = ti, Aggregations = aggregations }).Tag("Search").Identity(CurrentUser.EmailAddress).Property("User", CurrentUser).SetHttpContext(HttpContext)))
_logger.LogError(ex, "An error has occurred. Please check your filter or aggregations.");
return(BadRequest("An error has occurred. Please check your search filter."));
}
return(Ok(result));
}
public async Task <ActionResult <IReadOnlyCollection <Stack> > > GetByProjectAsync(string projectId = null, string filter = null, string sort = null, string time = null, string offset = null, string mode = null, int page = 1, int limit = 10)
{
var project = await GetProjectAsync(projectId);
if (project == null)
{
return(NotFound());
}
var organization = await GetOrganizationAsync(project.OrganizationId);
if (organization == null)
{
return(NotFound());
}
if (organization.IsSuspended)
{
return(PlanLimitReached("Unable to view stack occurrences for the suspended organization."));
}
var ti = GetTimeInfo(time, offset, organization.GetRetentionUtcCutoff(project, _options.MaximumRetentionDays));
var sf = new AppFilter(project, organization);
return(await GetInternalAsync(sf, ti, filter, sort, mode, page, limit));
}
public VictimView GetListOfVictimsProfile(AppFilter filterApp)
{
var victimList = _unitOfWork.victimProfileRepository.Find(c => c.VictimStatus == true)
.Where(c => filterApp.filters.rules[0].Data == "" ||
c.LastName.Trim().Contains(filterApp.filters.rules[0].Data.Trim()) ||
c.LastName.Trim().Contains(filterApp.filters.rules[0].Data.Trim()));
if (victimList.Count() > 0)
{
var victims = victimList
.OrderBy(c => filterApp.sidx)
.Skip((filterApp.page - 1) * filterApp.rows)
.Take(filterApp.rows)
.ToList();
var victimsView = new VictimView()
{
Data = Mapper.Map <List <VictimProfile>, List <VictimViewModel> >(victims),
Records = victimList.Count(),
};
return(victimsView);
}
return(new VictimView());
}
public async Task <ActionResult <IReadOnlyCollection <ViewProject> > > GetAsync(string filter = null, string sort = null, int page = 1, int limit = 10, string mode = null)
{
var organizations = await GetSelectedOrganizationsAsync(_organizationRepository, _projectRepository, _stackRepository, filter);
if (organizations.Count == 0)
{
return(Ok(EmptyModels));
}
page = GetPage(page);
limit = GetLimit(limit, 1000);
var sf = new AppFilter(organizations)
{
IsUserOrganizationsFilter = true
};
var projects = await _repository.GetByFilterAsync(sf, filter, sort, o => o.PageNumber(page).PageLimit(limit));
var viewProjects = await MapCollectionAsync <ViewProject>(projects.Documents, true);
if (!String.IsNullOrEmpty(mode) && String.Equals(mode, "stats", StringComparison.OrdinalIgnoreCase))
{
return(OkWithResourceLinks(await PopulateProjectStatsAsync(viewProjects.ToList()), projects.HasMore && !NextPageExceedsSkipLimit(page, limit), page, projects.Total));
}
return(OkWithResourceLinks(viewProjects, projects.HasMore && !NextPageExceedsSkipLimit(page, limit), page, projects.Total));
}
private async Task <string> GetNextEventIdAsync(PersistentEvent ev, AppFilter systemFilter = null, string userFilter = null, DateTime?utcStart = null, DateTime?utcEnd = null)
{
if (ev == null)
{
return(null);
}
if (!utcStart.HasValue || utcStart.Value.IsBefore(ev.Date.UtcDateTime))
{
utcStart = ev.Date.UtcDateTime;
}
if (!utcEnd.HasValue || utcEnd.Value.IsAfter(SystemClock.UtcNow))
{
utcEnd = SystemClock.UtcNow;
}
var utcEventDate = ev.Date.UtcDateTime;
// utcEnd is before the current event date.
if (utcStart > utcEventDate || utcEnd < utcEventDate)
{
return(null);
}
if (String.IsNullOrEmpty(userFilter))
{
userFilter = String.Concat(EventIndex.Alias.StackId, ":", ev.StackId);
}
var results = await FindAsync(q => q
.DateRange(utcEventDate, utcEnd, (PersistentEvent e) => e.Date)
.Index(utcEventDate, utcEnd)
.SortAscending(e => e.Date)
.Include(e => e.Id, e => e.Date)
.AppFilter(systemFilter)
.ElasticFilter(!Query <PersistentEvent> .Ids(ids => ids.Values(ev.Id)))
.FilterExpression(userFilter), o => o.PageLimit(10)).AnyContext();
if (results.Total == 0)
{
return(null);
}
// make sure we don't have records with the exact same occurrence date
if (results.Documents.All(t => t.Date != ev.Date))
{
return(results.Documents.OrderBy(t => t.Date).ThenBy(t => t.Id).First().Id);
}
// we have records with the exact same occurrence date, we need to figure out the order of those
// put our target error into the mix, sort it and return the result after the target
var unionResults = results.Documents.Union(new[] { ev })
.OrderBy(t => t.Date.Ticks).ThenBy(t => t.Id)
.ToList();
int index = unionResults.FindIndex(t => t.Id == ev.Id);
return(index == unionResults.Count - 1 ? null : unionResults[index + 1].Id);
}
private async Task <List <ViewOrganization> > PopulateOrganizationStatsAsync(List <ViewOrganization> viewOrganizations)
{
if (viewOrganizations.Count <= 0)
{
return(viewOrganizations);
}
int maximumRetentionDays = _options.MaximumRetentionDays;
var organizations = viewOrganizations.Select(o => new Organization {
Id = o.Id, CreatedUtc = o.CreatedUtc, RetentionDays = o.RetentionDays
}).ToList();
var sf = new AppFilter(organizations);
var systemFilter = new RepositoryQuery <PersistentEvent>().AppFilter(sf).DateRange(organizations.GetRetentionUtcCutoff(maximumRetentionDays), SystemClock.UtcNow, (PersistentEvent e) => e.Date).Index(organizations.GetRetentionUtcCutoff(maximumRetentionDays), SystemClock.UtcNow);
var result = await _eventRepository.CountAsync(q => q.SystemFilter(systemFilter).AggregationsExpression($"terms:(organization_id~{viewOrganizations.Count} cardinality:stack_id)"));
foreach (var organization in viewOrganizations)
{
var organizationStats = result.Aggregations.Terms <string>("terms_organization_id")?.Buckets.FirstOrDefault(t => t.Key == organization.Id);
organization.EventCount = organizationStats?.Total ?? 0;
organization.StackCount = (long?)organizationStats?.Aggregations.Cardinality("cardinality_stack_id")?.Value ?? 0;
organization.ProjectCount = await _projectRepository.GetCountByOrganizationIdAsync(organization.Id);
}
return(viewOrganizations);
}
private async Task <List <ViewProject> > PopulateProjectStatsAsync(List <ViewProject> viewProjects)
{
if (viewProjects.Count <= 0)
{
return(viewProjects);
}
int maximumRetentionDays = _options.MaximumRetentionDays;
var organizations = await _organizationRepository.GetByIdsAsync(viewProjects.Select(p => p.OrganizationId).ToArray(), o => o.Cache());
var projects = viewProjects.Select(p => new Project {
Id = p.Id, CreatedUtc = p.CreatedUtc, OrganizationId = p.OrganizationId
}).ToList();
var sf = new AppFilter(projects, organizations);
var systemFilter = new RepositoryQuery <PersistentEvent>().AppFilter(sf).DateRange(organizations.GetRetentionUtcCutoff(maximumRetentionDays), SystemClock.UtcNow, (PersistentEvent e) => e.Date).Index(organizations.GetRetentionUtcCutoff(maximumRetentionDays), SystemClock.UtcNow);
var result = await _eventRepository.CountAsync(q => q
.SystemFilter(systemFilter)
.AggregationsExpression($"terms:(project_id~{viewProjects.Count} cardinality:stack_id)")
.EnforceEventStackFilter(false));
foreach (var project in viewProjects)
{
var term = result.Aggregations.Terms <string>("terms_project_id")?.Buckets.FirstOrDefault(t => t.Key == project.Id);
project.EventCount = term?.Total ?? 0;
project.StackCount = (long)(term?.Aggregations.Cardinality("cardinality_stack_id")?.Value ?? 0);
}
return(viewProjects);
}
private async Task <string> GetPreviousEventIdAsync(PersistentEvent ev, AppFilter systemFilter = null, DateTime?utcStart = null, DateTime?utcEnd = null)
{
if (ev == null)
{
return(null);
}
var retentionDate = _options.MaximumRetentionDays > 0 ? SystemClock.UtcNow.Date.SubtractDays(_options.MaximumRetentionDays) : DateTime.MinValue;
if (!utcStart.HasValue || utcStart.Value.IsBefore(retentionDate))
{
utcStart = retentionDate;
}
if (!utcEnd.HasValue || utcEnd.Value.IsAfter(ev.Date.UtcDateTime))
{
utcEnd = ev.Date.UtcDateTime;
}
var utcEventDate = ev.Date.UtcDateTime;
// utcEnd is before the current event date.
if (utcStart > utcEventDate || utcEnd < utcEventDate)
{
return(null);
}
var results = await FindAsync(q => q
.DateRange(utcStart, utcEventDate, (PersistentEvent e) => e.Date)
.Index(utcStart, utcEventDate)
.SortDescending(e => e.Date)
.Include(e => e.Id, e => e.Date)
.AppFilter(systemFilter)
.ElasticFilter(!Query <PersistentEvent> .Ids(ids => ids.Values(ev.Id)))
.FilterExpression(String.Concat(EventIndex.Alias.StackId, ":", ev.StackId))
.EnforceEventStackFilter(false), o => o.PageLimit(10)).AnyContext();
if (results.Total == 0)
{
return(null);
}
// make sure we don't have records with the exact same occurrence date
if (results.Documents.All(t => t.Date != ev.Date))
{
return(results.Documents.OrderByDescending(t => t.Date).ThenByDescending(t => t.Id).First().Id);
}
// we have records with the exact same occurrence date, we need to figure out the order of those
// put our target error into the mix, sort it and return the result before the target
var unionResults = results.Documents.Union(new[] { ev })
.OrderBy(t => t.Date.UtcTicks).ThenBy(t => t.Id)
.ToList();
int index = unionResults.FindIndex(t => t.Id == ev.Id);
return(index == 0 ? null : unionResults[index - 1].Id);
}
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 void AppFilterTest()
{
// get test
Assert.That(AppFilter.Installed.ToString(), Is.EqualTo("installed"));
Assert.That(AppFilter.Featured.ToString(), Is.EqualTo("featured"));
// parse test
Assert.That(AppFilter.FromJsonString("installed"), Is.EqualTo(AppFilter.Installed));
Assert.That(AppFilter.FromJsonString("featured"), Is.EqualTo(AppFilter.Featured));
}
public static T AppFilter <T>(this T query, AppFilter filter) where T : IRepositoryQuery
{
if (filter != null)
{
return(query.BuildOption(SystemFilterKey, filter));
}
return(query);
}
public HttpResponseMessage GetDonors(AppFilter filter)
{
var donors = _admin.GetListOfDonors(filter);
if (donors != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, donors));
}
return(Request.CreateResponse(HttpStatusCode.NotFound, "Donors not found."));
}
public void AppFilterTest()
{
// get test
Assert.That(actual: AppFilter.Installed.ToString(), expression: Is.EqualTo(expected: "installed"));
Assert.That(actual: AppFilter.Featured.ToString(), expression: Is.EqualTo(expected: "featured"));
// parse test
Assert.That(actual: AppFilter.FromJsonString(response: "installed"), expression: Is.EqualTo(expected: AppFilter.Installed));
Assert.That(actual: AppFilter.FromJsonString(response: "featured"), expression: Is.EqualTo(expected: AppFilter.Featured));
}
public HttpResponseMessage GetVictimProfiles(AppFilter filter)
{
var profiles = _admin.GetListOfVictimsProfile(filter);
if (profiles != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, profiles));
}
return(Request.CreateResponse(HttpStatusCode.NotFound, "Victim Profiles not found."));
}
public Task <FindResults <Stack> > GetByFilterAsync(AppFilter 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 ?? InferField(s => s.LastOccurrence))
.AppFilter(systemFilter)
.FilterExpression(userFilter);
query = !String.IsNullOrEmpty(sort) ? query.SortExpression(sort) : query.SortDescending(s => s.LastOccurrence);
return(FindAsync(q => query, options));
}
public Task <FindResults <PersistentEvent> > GetByFilterAsync(AppFilter systemFilter, string userFilter, string sort, string field, DateTime utcStart, DateTime utcEnd, CommandOptionsDescriptor <PersistentEvent> options = null)
{
IRepositoryQuery <PersistentEvent> query = new RepositoryQuery <PersistentEvent>()
.DateRange(utcStart, utcEnd, field ?? InferField(e => e.Date))
.Index(utcStart, utcEnd)
.AppFilter(systemFilter)
.FilterExpression(userFilter);
query = !String.IsNullOrEmpty(sort) ? query.SortExpression(sort) : query.SortDescending(e => e.Date);
return(FindAsync(q => query, options));
}
public DonorEntity GetListOfDonors(AppFilter filter)
{
var donors = _unitOfWork.DonorRepository.Find(c => c.DonorStatus == true).ToList();
if (donors.Count() > 0)
{
var donorProfiles = new DonorEntity()
{
Data = Mapper.Map <List <Donor>, List <DonorEntityModel> >(donors),
Records = donors.Count,
};
return(donorProfiles);
}
return(null);
}
public async Task CanGetByStatus()
{
Log.MinimumLevel = Microsoft.Extensions.Logging.LogLevel.Trace;
var organizationRepository = GetService <IOrganizationRepository>();
var organization = await organizationRepository.GetByIdAsync(TestConstants.OrganizationId);
Assert.NotNull(organization);
await StackData.CreateSearchDataAsync(_repository, GetService <JsonSerializer>(), true);
var appFilter = new AppFilter(organization);
var stackIds = await _repository.GetIdsByQueryAsync(q => q.AppFilter(appFilter).FilterExpression("status:open OR status:regressed").DateRange(DateTime.UtcNow.AddDays(-5), DateTime.UtcNow), o => o.PageLimit(o.GetMaxLimit()));
Assert.Equal(2, stackIds.Total);
}
public IQueryable <App> GetApps(AppFilter filter)
{
var query = GetAvailableAppsForEndUser();
// Applying filters
if (filter.FeaturedApp.HasValue)
{
if (filter.FeaturedApp.Value)
{
query = query.Where(app => app.FeaturedApp != null);
}
else
{
query = query.Where(app => app.FeaturedApp == null);
}
}
if (filter.AppCategoryId.HasValue)
{
query = query.Where(app => app.AppCategoryId == filter.AppCategoryId);
}
if (filter.AppPricing.HasValue)
{
query =
filter.AppPricing.Value == AppPricing.FreeApp
? query.Where(app => app.Price == 0)
: query.Where(app => app.Price > 0);
}
if (filter.AppType.HasValue)
{
query = query.Where(app => app.AppCategory.AppType == filter.AppType.Value);
}
if (filter.AppOrderMethod == AppOrderMethod.Top)
{
query = query.OrderBy(app => app.AppVersions.Sum(appVersion => appVersion.Downloads));
}
else
{
// Ordering apps are necessery for server side Paging
query = query.OrderBy(app => app.Id);
}
return(query);
}
public async Task <ActionResult <IReadOnlyCollection <Stack> > > GetAsync(string filter = null, string sort = null, string time = null, string offset = null, string mode = null, int page = 1, int limit = 10)
{
var organizations = await GetSelectedOrganizationsAsync(_organizationRepository, _projectRepository, _stackRepository, filter);
if (organizations.Count(o => !o.IsSuspended) == 0)
{
return(Ok(EmptyModels));
}
var ti = GetTimeInfo(time, offset, organizations.GetRetentionUtcCutoff(_options.MaximumRetentionDays));
var sf = new AppFilter(organizations)
{
IsUserOrganizationsFilter = true
};
return(await GetInternalAsync(sf, ti, filter, sort, mode, page, limit));
}
public async Task <PreviousAndNextEventIdResult> GetPreviousAndNextEventIdsAsync(PersistentEvent ev, AppFilter systemFilter, string userFilter, DateTime?utcStart, DateTime?utcEnd)
{
var previous = GetPreviousEventIdAsync(ev, systemFilter, userFilter, utcStart, utcEnd);
var next = GetNextEventIdAsync(ev, systemFilter, userFilter, utcStart, utcEnd);
await Task.WhenAll(previous, next).AnyContext();
return(new PreviousAndNextEventIdResult {
Previous = previous.Result,
Next = next.Result
});
}
private async Task <Dictionary <string, double> > GetUserCountByProjectIdsAsync(ICollection <Stack> stacks, AppFilter sf, DateTime utcStart, DateTime utcEnd)
{
var scopedCacheClient = new ScopedCacheClient(_cache, $"Project:user-count:{utcStart.Floor(TimeSpan.FromMinutes(15)).Ticks}-{utcEnd.Floor(TimeSpan.FromMinutes(15)).Ticks}");
var projectIds = stacks.Select(s => s.ProjectId).Distinct().ToList();
var cachedTotals = await scopedCacheClient.GetAllAsync <double>(projectIds);
var totals = cachedTotals.Where(kvp => kvp.Value.HasValue).ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Value);
if (totals.Count == projectIds.Count)
{
return(totals);
}
var systemFilter = new RepositoryQuery <PersistentEvent>().AppFilter(sf).DateRange(utcStart, utcEnd, (PersistentEvent e) => e.Date).Index(utcStart, utcEnd);
var projects = cachedTotals.Where(kvp => !kvp.Value.HasValue).Select(kvp => new Project {
Id = kvp.Key, OrganizationId = stacks.FirstOrDefault(s => s.ProjectId == kvp.Key)?.OrganizationId
}).ToList();
var countResult = await _eventRepository.CountAsync(q => q.SystemFilter(systemFilter).FilterExpression(projects.BuildFilter()).AggregationsExpression("terms:(project_id cardinality:user)"));
// Cache all projects that have more than 10 users for 5 minutes.
var projectTerms = countResult.Aggregations.Terms <string>("terms_project_id").Buckets;
var aggregations = projectTerms.ToDictionary(t => t.Key, t => t.Aggregations.Cardinality("cardinality_user").Value.GetValueOrDefault());
await scopedCacheClient.SetAllAsync(aggregations.Where(t => t.Value >= 10).ToDictionary(k => k.Key, v => v.Value), TimeSpan.FromMinutes(5));
totals.AddRange(aggregations);
return(totals);
}
private async Task <ICollection <StackSummaryModel> > GetStackSummariesAsync(ICollection <Stack> stacks, IReadOnlyCollection <KeyedBucket <string> > stackTerms, AppFilter sf, TimeInfo ti)
{
if (stacks.Count == 0)
{
return(new List <StackSummaryModel>(0));
}
var totalUsers = await GetUserCountByProjectIdsAsync(stacks, sf, ti.Range.UtcStart, ti.Range.UtcEnd);
return(stacks.Join(stackTerms, s => s.Id, tk => tk.Key, (stack, term) => {
var data = _formattingPluginManager.GetStackSummaryData(stack);
var summary = new StackSummaryModel {
TemplateKey = data.TemplateKey,
Data = data.Data,
Id = stack.Id,
Title = stack.Title,
Status = stack.Status,
FirstOccurrence = term.Aggregations.Min <DateTime>("min_date").Value,
LastOccurrence = term.Aggregations.Max <DateTime>("max_date").Value,
Total = (long)(term.Aggregations.Sum("sum_count").Value ?? term.Total.GetValueOrDefault()),
Users = term.Aggregations.Cardinality("cardinality_user").Value.GetValueOrDefault(),
TotalUsers = totalUsers.GetOrDefault(stack.ProjectId)
};
return summary;
}).ToList());
}
private async Task <bool> SendSummaryNotificationAsync(Project project, SummaryNotification data)
{
// TODO: Add slack daily summaries
var userIds = project.NotificationSettings.Where(n => n.Value.SendDailySummary && !String.Equals(n.Key, Project.NotificationIntegrations.Slack)).Select(n => n.Key).ToList();
if (userIds.Count == 0)
{
_logger.LogInformation("Project {ProjectName} has no users to send summary to.", project.Name);
return(false);
}
var results = await _userRepository.GetByIdsAsync(userIds, o => o.Cache()).AnyContext();
var users = results.Where(u => u.IsEmailAddressVerified && u.EmailNotificationsEnabled && u.OrganizationIds.Contains(project.OrganizationId)).ToList();
if (users.Count == 0)
{
_logger.LogInformation("Project {ProjectName} has no users to send summary to.", project.Name);
return(false);
}
// TODO: What should we do about suspended organizations.
var organization = await _organizationRepository.GetByIdAsync(project.OrganizationId, o => o.Cache()).AnyContext();
if (organization == null)
{
_logger.LogInformation("The organization {organization} for project {ProjectName} may have been deleted. No summaries will be sent.", project.OrganizationId, project.Name);
return(false);
}
_logger.LogInformation("Sending daily summary: users={UserCount} project={project}", users.Count, project.Id);
var sf = new AppFilter(project, organization);
var systemFilter = new RepositoryQuery <PersistentEvent>().AppFilter(sf).DateRange(data.UtcStartTime, data.UtcEndTime, (PersistentEvent e) => e.Date).Index(data.UtcStartTime, data.UtcEndTime);
string filter = "type:error (status:open OR status:regressed)";
var result = await _eventRepository.CountAsync(q => q.SystemFilter(systemFilter).FilterExpression(filter).EnforceEventStackFilter().AggregationsExpression("terms:(first @include:true) terms:(stack_id~3) cardinality:stack_id sum:count~1")).AnyContext();
double total = result.Aggregations.Sum("sum_count")?.Value ?? result.Total;
double newTotal = result.Aggregations.Terms <double>("terms_first")?.Buckets.FirstOrDefault()?.Total ?? 0;
double uniqueTotal = result.Aggregations.Cardinality("cardinality_stack_id")?.Value ?? 0;
bool hasSubmittedEvents = total > 0 || project.IsConfigured.GetValueOrDefault();
bool isFreePlan = organization.PlanId == _plans.FreePlan.Id;
string fixedFilter = "type:error status:fixed";
var fixedResult = await _eventRepository.CountAsync(q => q.SystemFilter(systemFilter).FilterExpression(fixedFilter).EnforceEventStackFilter().AggregationsExpression("sum:count~1")).AnyContext();
double fixedTotal = fixedResult.Aggregations.Sum("sum_count")?.Value ?? fixedResult.Total;
var range = new DateTimeRange(data.UtcStartTime, data.UtcEndTime);
var usages = project.OverageHours.Where(u => range.Contains(u.Date)).ToList();
int blockedTotal = usages.Sum(u => u.Blocked);
int tooBigTotal = usages.Sum(u => u.TooBig);
IReadOnlyCollection <Stack> mostFrequent = null;
var stackTerms = result.Aggregations.Terms <string>("terms_stack_id");
if (stackTerms?.Buckets.Count > 0)
{
mostFrequent = await _stackRepository.GetByIdsAsync(stackTerms.Buckets.Select(b => b.Key).ToArray()).AnyContext();
}
IReadOnlyCollection <Stack> newest = null;
if (newTotal > 0)
{
newest = (await _stackRepository.FindAsync(q => q.AppFilter(sf).FilterExpression(filter).SortExpression("-first").DateRange(data.UtcStartTime, data.UtcEndTime, "first"), o => o.PageLimit(3)).AnyContext()).Documents;
}
foreach (var user in users)
{
_logger.LogInformation("Queuing {ProjectName} daily summary email ({UtcStartTime}-{UtcEndTime}) for user {EmailAddress}.", project.Name, data.UtcStartTime, data.UtcEndTime, user.EmailAddress);
await _mailer.SendProjectDailySummaryAsync(user, project, mostFrequent, newest, data.UtcStartTime, hasSubmittedEvents, total, uniqueTotal, newTotal, fixedTotal, blockedTotal, tooBigTotal, isFreePlan).AnyContext();
}
_logger.LogInformation("Done sending daily summary: users={UserCount} project={ProjectName} events={EventCount}", users.Count, project.Name, total);
return(true);
}
private async Task <ActionResult <IReadOnlyCollection <Stack> > > GetInternalAsync(AppFilter sf, TimeInfo ti, string filter = null, string sort = null, string mode = null, int page = 1, int limit = 10)
{
page = GetPage(page);
limit = GetLimit(limit);
int skip = GetSkip(page, limit);
if (skip > MAXIMUM_SKIP)
{
return(Ok(EmptyModels));
}
var pr = await _validator.ValidateQueryAsync(filter);
if (!pr.IsValid)
{
return(BadRequest(pr.Message));
}
sf.UsesPremiumFeatures = pr.UsesPremiumFeatures;
try {
var results = await _repository.FindAsync(q => q.AppFilter(ShouldApplySystemFilter(sf, filter) ? sf : null).FilterExpression(filter).SortExpression(sort).DateRange(ti.Range.UtcStart, ti.Range.UtcEnd, ti.Field), o => o.PageNumber(page).PageLimit(limit));
var stacks = results.Documents.Select(s => s.ApplyOffset(ti.Offset)).ToList();
if (!String.IsNullOrEmpty(mode) && String.Equals(mode, "summary", StringComparison.OrdinalIgnoreCase))
{
return(OkWithResourceLinks(await GetStackSummariesAsync(stacks, sf, ti), results.HasMore && !NextPageExceedsSkipLimit(page, limit), page));
}
return(OkWithResourceLinks(stacks, results.HasMore && !NextPageExceedsSkipLimit(page, limit), page));
}
catch (ApplicationException ex) {
using (_logger.BeginScope(new ExceptionlessState().Property("Search Filter", new { SystemFilter = sf, UserFilter = filter, Time = ti, Page = page, Limit = limit }).Tag("Search").Identity(CurrentUser.EmailAddress).Property("User", CurrentUser).SetHttpContext(HttpContext)))
_logger.LogError(ex, "An error has occurred. Please check your search filter.");
return(BadRequest("An error has occurred. Please check your search filter."));
}
}
public static async Task <PreviousAndNextEventIdResult> GetPreviousAndNextEventIdsAsync(this IEventRepository repository, string id, AppFilter systemFilter = null, DateTime?utcStart = null, DateTime?utcEnd = null)
{
var ev = await repository.GetByIdAsync(id, o => o.Cache()).AnyContext();
return(await repository.GetPreviousAndNextEventIdsAsync(ev, systemFilter, utcStart, utcEnd).AnyContext());
}
private async Task <ICollection <StackSummaryModel> > GetStackSummariesAsync(ICollection <Stack> stacks, AppFilter eventSystemFilter, TimeInfo ti)
{
if (stacks.Count == 0)
{
return(new List <StackSummaryModel>());
}
var systemFilter = new RepositoryQuery <PersistentEvent>().AppFilter(eventSystemFilter).DateRange(ti.Range.UtcStart, ti.Range.UtcEnd, (PersistentEvent e) => e.Date).Index(ti.Range.UtcStart, ti.Range.UtcEnd);
var stackTerms = await _eventRepository.CountAsync(q => q.SystemFilter(systemFilter).FilterExpression(String.Join(" OR ", stacks.Select(r => $"stack:{r.Id}"))).AggregationsExpression($"terms:(stack_id~{stacks.Count} cardinality:user sum:count~1 min:date max:date)"));
return(await GetStackSummariesAsync(stacks, stackTerms.Aggregations.Terms <string>("terms_stack_id").Buckets, eventSystemFilter, ti));
}
private void LoadWebPartView(ExtentrixWIWebPart wp)
{
//if (Page.Session[PublishedApps] == null)
PublishedApplication[] publishedApps = Page.Session[PublishedApps] as PublishedApplication[];
if (!Page.IsPostBack && publishedApps == null)
{
var watch = Stopwatch.StartNew();
Logger.Default.Info(LogLocation, string.Format("LoadWebPartView: Start getting applications {0}", DateTime.Now));
DelegateGetApplications delGetApp = new DelegateGetApplications(wp.getApplication);
IAsyncResult result = delGetApp.BeginInvoke(Credentials, null, null);
publishedApps = delGetApp.EndInvoke(result);
Logger.Default.Info(LogLocation, string.Format("LoadWebPartView: End getting applications {0}", watch.Elapsed));
//check is app filter applied
if ((publishedApps != null) && (publishedApps.Length > 0))
{
Page.Session[PublishedApps] = publishedApps;
new Thread(() => wp.ProcessIcons(Credentials, wp.getService())).Start();
}
}
if (publishedApps != null)
{
if (IsAppFilterApplied)
{
var appsFiltered = new List <PublishedApplication>();
string[] filter = AppFilter.Split(',');
for (int i = 0; i < filter.Length; i++)
{
foreach (PublishedApplication app in publishedApps)
{
if (app.AppName.ToLower().Contains(filter[i].ToLower()))
{
appsFiltered.Add(app);
}
}
}
publishedApps = appsFiltered.ToArray();
}
Logger.Default.Info(LogLocation, "LoadWebPartView: Start creating app tree");
tree = new ApplicationsTree(publishedApps);
Logger.Default.Info(LogLocation, "LoadWebPartView: End creating app tree");
if (SPContext.Current.Web.CurrentUser != null)
{
favorites = new Favorites(tree);
}
}
if (SPContext.Current.Web.CurrentUser == null)
{
DropDownViewSwitcher.Items.Remove(DropDownViewSwitcher.Items.FindByText("Favorites"));
}
if ((publishedApps != null) && (publishedApps.Length > 0))
{
FillView(GetCurrentView(DropDownViewSwitcher.SelectedValue));
}
}
