public async Task <long> EarnedBadgeCountAsync(ReportCriterion request,
int?badgeId = null)
{
var eligibleUsers = GetEligibleUsers(request);
var badgeCount = DbSet
.AsNoTracking()
.Where(_ => _.BadgeId != null &&
!_.IsDeleted &&
eligibleUsers.Contains(_.User));
if (request.StartDate != null)
{
badgeCount = badgeCount
.Where(_ => _.CreatedAt >= request.StartDate);
}
if (request.EndDate != null)
{
badgeCount = badgeCount
.Where(_ => _.CreatedAt <= request.EndDate);
}
if (badgeId != null)
{
badgeCount = badgeCount
.Where(_ => _.BadgeId == badgeId);
}
return(await badgeCount.CountAsync());
}
public async Task <StatusSummary> GetCurrentStatsAsync(ReportCriterion request)
{
if (request.SiteId == null ||
request.SiteId != GetCurrentSiteId())
{
request.SiteId = GetCurrentSiteId();
}
string cacheKey = $"{CacheKey.CurrentStats}s{request.SiteId}p{request.ProgramId}sys{request.SystemId}b{request.BranchId}";
var summary = _memoryCache.Get <StatusSummary>(cacheKey);
if (summary == null)
{
summary = new StatusSummary
{
RegisteredUsers = await _userRepository.GetCountAsync(request),
Achievers = await _userRepository.GetAchieverCountAsync(request),
PointsEarned = await _userLogRepository.PointsEarnedTotalAsync(request),
ActivityEarnings = await _userLogRepository.ActivityEarningsTotalAsync(request),
CompletedChallenges = await _userLogRepository
.CompletedChallengeCountAsync(request),
BadgesEarned = await _userLogRepository.EarnedBadgeCountAsync(request),
DaysUntilEnd = await GetDaysUntilEnd()
};
_memoryCache.Set(cacheKey,
summary,
new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(5)));
}
return(summary);
}
public async Task <ICollection <VendorCode> > GetEarnedCodesAsync(ReportCriterion criterion)
{
// Includes deleted users
var validUsers = _context.Users.AsNoTracking()
.Where(_ => _.SiteId == criterion.SiteId);
if (criterion.IsFirstTimeParticipant == true)
{
validUsers = validUsers.Where(_ => _.IsFirstTime == true);
}
if (criterion.BranchId.HasValue)
{
validUsers = validUsers.Where(_ => _.BranchId == criterion.BranchId.Value);
}
else if (criterion.SystemId.HasValue)
{
validUsers = validUsers.Where(_ => _.SystemId == criterion.SystemId.Value);
}
return(await(from vendorCodes in DbSet.AsNoTracking()
.Where(_ => _.UserId.HasValue && _.SiteId == criterion.SiteId)
join users in validUsers
on vendorCodes.UserId equals users.Id
select vendorCodes)
.ProjectTo <VendorCode>()
.ToListAsync());
}
public async Task <long> CompletedChallengeCountAsync(ReportCriterion request,
int?challengeId = null)
{
var eligibleUsers = GetEligibleUsers(request);
var challengeCount = DbSet
.AsNoTracking()
.Where(_ => _.ChallengeId != null &&
!_.IsDeleted &&
eligibleUsers.Contains(_.User));
if (request.StartDate != null)
{
challengeCount = challengeCount
.Where(_ => _.CreatedAt >= request.StartDate);
}
if (request.EndDate != null)
{
challengeCount = challengeCount
.Where(_ => _.CreatedAt <= request.EndDate);
}
if (challengeId != null)
{
challengeCount = challengeCount
.Where(_ => _.ChallengeId == challengeId);
}
return(await challengeCount.CountAsync());
}
private IQueryable <Model.UserLog> GetEligibleUserLogs(ReportCriterion request)
{
if (request.ProgramId != null ||
request.SystemId != null ||
request.BranchId != null)
{
var eligibleUserLogs = DbSet
.AsNoTracking()
.Where(_ => _.User.SiteId == request.SiteId &&
_.IsDeleted == false &&
_.User.IsDeleted == false);
if (request.ProgramId != null)
{
eligibleUserLogs = eligibleUserLogs.Where(_ => _.User.ProgramId == request.ProgramId);
}
if (request.SystemId != null)
{
eligibleUserLogs = eligibleUserLogs.Where(_ => _.User.SystemId == request.SystemId);
}
if (request.BranchId != null)
{
eligibleUserLogs = eligibleUserLogs.Where(_ => _.User.BranchId == request.BranchId);
}
return(eligibleUserLogs);
}
else
{
return(DbSet
.AsNoTracking()
.Where(_ => _.User.SiteId == request.SiteId &&
_.IsDeleted == false &&
_.User.IsDeleted == false));
}
}
private async Task <ICollection <int> > GetEligibleUserIds(ReportCriterion request)
{
if (request.ProgramId != null ||
request.SystemId != null ||
request.BranchId != null)
{
var eligibleUsers = _context.Users
.AsNoTracking()
.Where(_ => _.SiteId == request.SiteId && _.IsDeleted == false);
if (request.ProgramId != null)
{
eligibleUsers = eligibleUsers.Where(_ => _.ProgramId == request.ProgramId);
}
if (request.SystemId != null)
{
eligibleUsers = eligibleUsers.Where(_ => _.SystemId == request.SystemId);
}
if (request.BranchId != null)
{
eligibleUsers = eligibleUsers.Where(_ => _.BranchId == request.BranchId);
}
return(await eligibleUsers.Select(_ => _.Id).ToListAsync());
}
else
{
return(null);
}
}
public async Task <long> PointsEarnedTotalAsync(ReportCriterion request)
{
var eligibleUserIds = await GetEligibleUserIds(request);
var pointCount = DbSet
.Where(_ => _.IsDeleted == false && _.User.IsDeleted == false)
.AsNoTracking();
if (eligibleUserIds != null)
{
pointCount = pointCount.Where(_ => eligibleUserIds.Contains(_.UserId));
}
if (request.StartDate != null)
{
pointCount = pointCount
.Where(_ => _.CreatedAt >= request.StartDate);
}
if (request.EndDate != null)
{
pointCount = pointCount
.Where(_ => _.CreatedAt <= request.EndDate);
}
return(await pointCount.SumAsync(_ => Convert.ToInt64(_.PointsEarned)));
}
public async Task <int> RequestReport(ReportCriterion criterion, int reportId)
{
// returns report request id
if (HasPermission(Permission.ViewAllReporting))
{
if (criterion.SiteId == null || criterion.SiteId != GetCurrentSiteId())
{
criterion.SiteId = GetCurrentSiteId();
}
criterion.CreatedAt = _dateTimeProvider.Now;
criterion.CreatedBy = GetActiveUserId();
criterion = await _reportCriterionRepository.AddSaveNoAuditAsync(criterion);
var reportRequest = await _reportRequestRepository
.AddSaveNoAuditAsync(new ReportRequest
{
CreatedAt = criterion.CreatedAt,
CreatedBy = criterion.CreatedBy,
ReportCriteriaId = criterion.Id,
ReportId = reportId,
Name = GetReportList().Where(_ => _.Id == reportId).SingleOrDefault()?.Name,
SiteId = criterion.SiteId,
});
return(reportRequest.Id);
}
else
{
var requestingUser = GetClaimId(ClaimType.UserId);
_logger.LogError($"User {requestingUser} doesn't have permission to view all reporting.");
throw new GraException("Permission denied.");
}
}
public async Task <ICollection <int> > UserIdsEarnedBadgeAsync(int badgeId, ReportCriterion criterion)
{
return(await GetEligibleUserLogs(criterion)
.Where(_ => _.BadgeId == badgeId)
.Select(_ => _.UserId)
.ToListAsync());
}
public async Task <StatusSummary> GetCurrentStatsAsync(ReportCriterion request)
{
if (request.SiteId == null ||
request.SiteId != GetCurrentSiteId())
{
request.SiteId = GetCurrentSiteId();
}
string cacheKey = $"s{request.SiteId}.p{request.ProgramId}.sys{request.SystemId}.b{request.BranchId}.{CacheKey.CurrentStats}";
var summaryJson = _cache.GetString(cacheKey);
if (string.IsNullOrEmpty(summaryJson))
{
var summary = new StatusSummary
{
RegisteredUsers = await _userRepository.GetCountAsync(request),
Achievers = await _userRepository.GetAchieverCountAsync(request),
PointsEarned = await _userLogRepository.PointsEarnedTotalAsync(request),
CompletedChallenges = await _userLogRepository
.CompletedChallengeCountAsync(request),
BadgesEarned = await _userLogRepository.EarnedBadgeCountAsync(request),
DaysUntilEnd = await GetDaysUntilEnd()
};
_cache.SetString(cacheKey, JsonConvert.SerializeObject(summary), ExpireIn());
return(summary);
}
else
{
return(JsonConvert.DeserializeObject <StatusSummary>(summaryJson));
}
}
public async Task <long> TranslationEarningsAsync(ReportCriterion request,
ICollection <int?> translationIds)
{
// look up user id restrictions
var eligibleUserIds = await GetEligibleUserIds(request);
var earnedFilter = DbSet
.AsNoTracking()
.Where(_ => _.IsDeleted == false &&
_.User.IsDeleted == false &&
_.PointTranslationId != null &&
translationIds.Contains(_.PointTranslationId));
// filter by users if necessary
if (eligibleUserIds != null)
{
earnedFilter = earnedFilter.Where(_ => eligibleUserIds.Contains(_.UserId));
}
if (request.StartDate != null)
{
earnedFilter = earnedFilter
.Where(_ => _.CreatedAt >= request.StartDate);
}
if (request.EndDate != null)
{
earnedFilter = earnedFilter
.Where(_ => _.CreatedAt <= request.EndDate);
}
return(await earnedFilter.SumAsync(_ => Convert.ToInt64(_.ActivityEarned)));
}
public async Task <long> EarnedBadgeCountAsync(ReportCriterion request)
{
var eligibleUserIds = await GetEligibleUserIds(request);
var badgeCount = DbSet
.AsNoTracking()
.Where(_ => _.BadgeId != null &&
_.IsDeleted == false &&
_.User.IsDeleted == false);
if (eligibleUserIds != null)
{
badgeCount = badgeCount.Where(_ => eligibleUserIds.Contains(_.UserId));
}
if (request.StartDate != null)
{
badgeCount = badgeCount
.Where(_ => _.CreatedAt >= request.StartDate);
}
if (request.EndDate != null)
{
badgeCount = badgeCount
.Where(_ => _.CreatedAt <= request.EndDate);
}
return(await badgeCount.CountAsync());
}
GetCommunityExperienceAttendanceAsync(ReportCriterion criterion)
{
var communityExperiences = DbSet
.AsNoTracking()
.Where(_ => _.IsCommunityExperience && _.RelatedTriggerId.HasValue);
if (criterion.BranchId.HasValue)
{
communityExperiences = communityExperiences
.Where(_ => _.RelatedBranchId == criterion.BranchId);
}
else if (criterion.SystemId.HasValue)
{
communityExperiences = communityExperiences
.Where(_ => _.RelatedSystemId == criterion.SystemId);
}
var experienceWithCount = communityExperiences
.ProjectTo <Event>()
.GroupJoin(_context.UserTriggers,
c => c.RelatedTriggerId.Value,
ut => ut.TriggerId,
(c, e) => new { c, e })
.Select(_ => new DataWithCount <Event>()
{
Data = _.c,
Count = _.e.Count()
});
return(await experienceWithCount
.OrderBy(_ => _.Data.Name)
.ToListAsync());
}
public async Task <IActionResult> Run(ReportCriteriaViewModel viewModel)
{
PageTitle = "Run the report";
var criterion = new ReportCriterion
{
SiteId = GetCurrentSiteId(),
EndDate = viewModel.EndDate,
StartDate = viewModel.StartDate,
SystemId = viewModel.SystemId,
BranchId = viewModel.BranchId,
ProgramId = viewModel.ProgramId,
SchoolDistrictId = viewModel.SchoolDistrictId,
SchoolId = viewModel.SchoolId,
GroupInfoId = viewModel.GroupInfoId,
VendorCodeTypeId = viewModel.VendorCodeTypeId,
BadgeRequiredList = viewModel.BadgeRequiredList,
ChallengeRequiredList = viewModel.ChallengeRequiredList
};
var reportRequestId = await _reportService
.RequestReport(criterion, viewModel.ReportId);
var wsUrl = await _siteService.GetWsUrl(Request.Scheme, Request.Host.Value);
return(View("Run", new RunReportViewModel
{
Id = reportRequestId,
RunReportUrl = $"{wsUrl}/MissionControl/runreport/{reportRequestId}"
}));
}
public async Task <IEnumerable <User> > GetTopScoresAsync(ReportCriterion criterion, int scoresToReturn)
{
return(await ApplyUserFilter(criterion)
.OrderByDescending(_ => _.PointsEarned)
.Take(scoresToReturn)
.ProjectTo <User>()
.ToListAsync());
}
public async Task <IActionResult> Run(ReportCriteriaViewModel viewModel)
{
PageTitle = "Run the report";
var siteId = GetCurrentSiteId();
var criterion = new ReportCriterion
{
SiteId = siteId,
EndDate = viewModel.EndDate,
StartDate = viewModel.StartDate,
SystemId = viewModel.SystemId,
BranchId = viewModel.BranchId,
ProgramId = viewModel.ProgramId,
SchoolDistrictId = viewModel.SchoolDistrictId,
SchoolId = viewModel.SchoolId,
GroupInfoId = viewModel.GroupInfoId,
VendorCodeTypeId = viewModel.VendorCodeTypeId,
BadgeRequiredList = viewModel.BadgeRequiredList,
ChallengeRequiredList = viewModel.ChallengeRequiredList
};
if (viewModel.TriggerList?.Count > 0)
{
criterion.TriggerList = string.Join(",", viewModel.TriggerList);
}
var(IsSet, SetValue) = await _siteLookupService.GetSiteSettingIntAsync(siteId,
SiteSettingKey.Users.MaximumActivityPermitted);
if (IsSet)
{
criterion.MaximumAllowableActivity = SetValue;
}
int reportRequestId = await _reportService
.RequestReport(criterion, viewModel.ReportId);
var jobToken = await _jobService.CreateJobAsync(new Job
{
JobType = JobType.RunReport,
SerializedParameters = JsonConvert.SerializeObject(new JobDetailsRunReport
{
ReportRequestId = reportRequestId
})
});
return(View("Job", new ViewModel.MissionControl.Shared.JobViewModel
{
CancelUrl = Url.Action(nameof(Index)),
JobToken = jobToken.ToString(),
PingSeconds = 2,
SuccessRedirectUrl = Url.Action(nameof(View), new { id = reportRequestId }),
SuccessUrl = "",
Title = "Loading report..."
}));
}
public async Task <List <int> > GetUserIdsByBranchProgram(ReportCriterion criterion)
{
return(await DbSet
.AsNoTracking()
.Where(_ => _.IsDeleted == false &&
_.BranchId == criterion.BranchId &&
_.ProgramId == criterion.ProgramId)
.Select(_ => _.Id)
.ToListAsync());
}
protected async Task <bool> GetSiteSettingBoolInternalAsync(ReportCriterion criterion, string key)
{
var settings
= await _serviceFacade
.SiteSettingRepository
.GetBySiteIdAsync((int)criterion.SiteId);
var setting = settings.Where(_ => _.Key == key);
return(setting.SingleOrDefault()?.Value != null);
}
public async Task <long> GetEarningsOverPeriodAsync(int userId, ReportCriterion criterion)
{
return(await DbSet
.AsNoTracking()
.Where(_ => _.UserId == userId &&
_.IsDeleted == false &&
_.PointsEarned > 0 &&
_.CreatedAt >= criterion.StartDate &&
_.CreatedAt <= criterion.EndDate)
.SumAsync(_ => Convert.ToInt64(_.PointsEarned)));
}
protected Task <bool> GetSiteSettingBoolAsync(ReportCriterion criterion, string key)
{
if (criterion == null)
{
throw new ArgumentNullException(nameof(criterion));
}
if (criterion.SiteId == null)
{
throw new ArgumentException($"Must provide {nameof(criterion.SiteId)} to execute a report.");
}
return(GetSiteSettingBoolInternalAsync(criterion, key));
}
private IQueryable <Model.User> ApplyUserFilter(ReportCriterion criterion)
{
var userList = DbSet.AsNoTracking()
.Where(_ => _.IsDeleted == false && _.SiteId == criterion.SiteId);
if (criterion.SystemId != null)
{
userList = userList.Where(_ => criterion.SystemId == _.SystemId);
}
if (criterion.BranchId != null)
{
userList = userList.Where(_ => criterion.BranchId == _.BranchId);
}
if (criterion.ProgramId != null)
{
userList = userList.Where(_ => criterion.ProgramId == _.ProgramId);
}
if (criterion.StartDate != null)
{
userList = userList.Where(_ => _.CreatedAt >= criterion.StartDate);
}
if (criterion.EndDate != null)
{
userList = userList.Where(_ => _.CreatedAt <= criterion.EndDate);
}
if (criterion.SchoolId != null)
{
userList = userList.Where(_ => _.SchoolId == criterion.SchoolId);
}
if (criterion.VendorCodeTypeId != null)
{
userList = userList.Join(_context.VendorCodes,
u => u.Id,
v => v.UserId,
(u, v) => new { u, v })
.Where(_ => _.v.VendorCodeTypeId == criterion.VendorCodeTypeId.Value &&
_.v.IsDonated == true)
.Select(_ => _.u);
}
return(userList);
}
public async Task <long> TranslationEarningsAsync(ReportCriterion request,
ICollection <int?> translationIds)
{
// look up user id restrictions
var eligibleUserIds = await GetEligibleUserIds(request);
var earnedFilter = DbSet
.AsNoTracking()
.Where(_ => _.IsDeleted == false &&
_.ActivityEarned != null &&
_.User.IsDeleted == false &&
_.PointTranslationId != null &&
translationIds.Contains(_.PointTranslationId));
// filter by users if necessary
if (eligibleUserIds != null)
{
earnedFilter = earnedFilter.Where(_ => eligibleUserIds.Contains(_.UserId));
if (MaximumAllowableActivity > 0)
{
return(await _context.Users
.Where(_ => eligibleUserIds.Contains(_.Id))
.GroupJoin(earnedFilter, u => u.Id, ul => ul.UserId, (u, ul) => new { User = u, Sum = (long)ul.Sum(_ => _.ActivityEarned) })
.Where(_ => _.Sum > 0)
.Select(_ => (_.Sum > MaximumAllowableActivity ? _.User.Program.AchieverPointAmount : _.Sum))
.SumAsync(_ => _));
}
}
// TODO Fix for reporting over a time period
/*
* if (request.StartDate != null)
* {
* earnedFilter = earnedFilter
* .Where(_ => _.CreatedAt >= request.StartDate);
* }
*
* if (request.EndDate != null)
* {
* earnedFilter = earnedFilter
* .Where(_ => _.CreatedAt <= request.EndDate);
* }
*/
return(await earnedFilter.SumAsync(_ => Convert.ToInt64(_.ActivityEarned)));
}
GetCommunityExperienceAttendanceAsync(ReportCriterion criterion)
{
var communityExperiences = DbSet
.AsNoTracking()
.Where(_ => _.IsCommunityExperience && _.RelatedTriggerId.HasValue);
if (criterion.BranchId.HasValue)
{
communityExperiences = communityExperiences
.Where(_ => _.RelatedBranchId == criterion.BranchId);
}
else if (criterion.SystemId.HasValue)
{
communityExperiences = communityExperiences
.Where(_ => _.RelatedSystemId == criterion.SystemId);
}
var communityExperienceList = (await communityExperiences
.ToListAsync())
.Select(_ => new DataWithCount <Event>
{
Data = _mapper.Map <Event>(_)
})
.OrderBy(_ => _.Data.Name)
.ToList();
var triggerCounts = await _context.UserTriggers
.AsNoTracking()
.Where(_ => communityExperiences
.Select(e => e.RelatedTriggerId)
.Contains(_.TriggerId))
.GroupBy(_ => _.TriggerId)
.Select(_ => new { _.Key, Count = _.Count() })
.ToListAsync();
foreach (var experience in communityExperienceList)
{
experience.Count = triggerCounts
.Where(_ => _.Key == experience.Data.RelatedTriggerId)
.Select(_ => _.Count)
.FirstOrDefault();
}
return(communityExperienceList);
}
protected async Task <bool> GetSiteSettingBoolAsync(ReportCriterion criterion, string key)
{
if (criterion == null)
{
throw new ArgumentNullException(nameof(criterion));
}
if (criterion.SiteId == null)
{
throw new ArgumentException("Must provide SiteId to execute a report.");
}
var settings
= await _serviceFacade.SiteSettingRepository.GetBySiteIdAsync((int)criterion.SiteId);
var setting = settings.Where(_ => _.Key == key);
return(setting.SingleOrDefault()?.Value != null);
}
public async Task <long> TranslationEarningsAsync(ReportCriterion request,
ICollection <int?> translationIds)
{
var eligibleUsers = GetEligibleUsers(request);
var earnedFilter = DbSet
.AsNoTracking()
.Where(_ => !_.IsDeleted &&
_.ActivityEarned != null &&
eligibleUsers.Contains(_.User) &&
_.PointTranslationId != null &&
translationIds.Contains(_.PointTranslationId));
if (request.MaximumAllowableActivity > 0)
{
return(await earnedFilter
.GroupBy(_ => _.UserId)
.Select(_ => _.Sum(s => Convert.ToInt64(s.ActivityEarned.Value)))
.Where(_ => _ > 0)
.Select(_ => _ > request.MaximumAllowableActivity.Value ? request.MaximumAllowableActivity.Value : _)
.SumAsync());
}
// TODO Fix for reporting over a time period
/*
* if (request.StartDate != null)
* {
* earnedFilter = earnedFilter
* .Where(_ => _.CreatedAt >= request.StartDate);
* }
*
* if (request.EndDate != null)
* {
* earnedFilter = earnedFilter
* .Where(_ => _.CreatedAt <= request.EndDate);
* }
*/
return(await earnedFilter.SumAsync(_ => Convert.ToInt64(_.ActivityEarned.Value)));
}
public async Task <ICollection <PrizeWinner> > GetUserPrizesAsync(ReportCriterion criterion)
{
var validUsers = _context.Users.AsNoTracking()
.Where(_ => !_.IsDeleted && _.SiteId == criterion.SiteId);
if (criterion.BranchId.HasValue)
{
validUsers = validUsers.Where(_ => _.BranchId == criterion.BranchId.Value);
}
else if (criterion.SystemId.HasValue)
{
validUsers = validUsers.Where(_ => _.SystemId == criterion.SystemId.Value);
}
return(await(from prizes in DbSet.Where(_ => _.SiteId == criterion.SiteId)
join users in validUsers
on prizes.UserId equals users.Id
select prizes)
.ProjectTo <PrizeWinner>(_mapper.ConfigurationProvider)
.ToListAsync());
}
private IQueryable <Model.User> GetEligibleUsers(ReportCriterion request)
{
var eligibleUsers = _context.Users
.AsNoTracking()
.Where(_ => _.SiteId == request.SiteId && !_.IsDeleted);
if (request.ProgramId != null)
{
eligibleUsers = eligibleUsers.Where(_ => _.ProgramId == request.ProgramId);
}
if (request.SystemId != null)
{
eligibleUsers = eligibleUsers.Where(_ => _.SystemId == request.SystemId);
}
if (request.BranchId != null)
{
eligibleUsers = eligibleUsers.Where(_ => _.BranchId == request.BranchId);
}
return(eligibleUsers);
}
public async Task <ICollection <PrizeWinner> > GetRedemptionsAsync(ReportCriterion criterion)
{
// Includes deleted users and users from other sites
var validUsers = _context.Users.AsNoTracking();
if (criterion.BranchId.HasValue)
{
validUsers = validUsers.Where(_ => _.BranchId == criterion.BranchId.Value);
}
else if (criterion.SystemId.HasValue)
{
validUsers = validUsers.Where(_ => _.SystemId == criterion.SystemId.Value);
}
return(await(from prizes in DbSet.AsNoTracking().Where(_ => _.RedeemedAt.HasValue &&
_.SiteId == criterion.SiteId)
join users in validUsers
on prizes.RedeemedBy equals users.Id
select prizes)
.ProjectTo <PrizeWinner>(_mapper.ConfigurationProvider)
.ToListAsync());
}
private IQueryable <Model.User> ApplyUserFilter(ReportCriterion criterion)
{
var userList = DbSet.AsNoTracking()
.Where(_ => _.IsDeleted == false && _.SiteId == criterion.SiteId);
if (criterion.SystemId != null)
{
userList = userList.Where(_ => criterion.SystemId == _.SystemId);
}
if (criterion.BranchId != null)
{
userList = userList.Where(_ => criterion.BranchId == _.BranchId);
}
if (criterion.ProgramId != null)
{
userList = userList.Where(_ => criterion.ProgramId == _.ProgramId);
}
if (criterion.StartDate != null)
{
userList = userList.Where(_ => _.CreatedAt >= criterion.StartDate);
}
if (criterion.EndDate != null)
{
userList = userList.Where(_ => _.CreatedAt <= criterion.EndDate);
}
if (criterion.SchoolId != null)
{
userList = userList.Where(_ => _.SchoolId == criterion.SchoolId);
}
return(userList);
}
public async Task <ICollection <int> > UserIdsCompletedChallengesAsync(int challengeId, ReportCriterion criterion)
{
return(await GetEligibleUserLogs(criterion)
.Where(_ => _.ChallengeId == challengeId)
.Select(_ => _.UserId)
.ToListAsync());
}
