MCGetPaginatedChallengeListAsync(ChallengeFilter filter)
{
int authUserId = GetClaimId(ClaimType.UserId);
if (HasPermission(Permission.ViewAllChallenges))
{
if (filter.IsActive == false)
{
if (!HasPermission(Permission.ActivateSystemChallenges) &&
!HasPermission(Permission.ActivateAllChallenges))
{
_logger.LogError($"User {authUserId} doesn't have permission to view pending challenges.");
throw new GraException("Permission denied.");
}
else if (!HasPermission(Permission.ActivateAllChallenges) &&
filter.SystemIds?.FirstOrDefault() != GetClaimId(ClaimType.SystemId))
{
_logger.LogError($"User {authUserId} doesn't have permission to view pending challenges for system.");
throw new GraException("Permission denied.");
}
}
filter.SiteId = GetCurrentSiteId();
var challenges = await _challengeRepository.PageAllAsync(filter);
await AddBadgeFilenames(challenges);
return(new DataWithCount <IEnumerable <Challenge> >
{
Data = challenges,
Count = await _challengeRepository.GetChallengeCountAsync(filter)
});
}
_logger.LogError($"User {authUserId} doesn't have permission to view all challenges.");
throw new GraException("Permission denied.");
}
public async Task <DataWithCount <IEnumerable <int> > > PageIdsAsync(ChallengeFilter filter,
int userId)
{
var user = await _context.Users.FindAsync(userId);
var challengeList = ApplyFilters(filter)
.Where(_ => (_.LimitToSystemId == null || _.LimitToSystemId == user.SystemId) &&
(_.LimitToBranchId == null || _.LimitToBranchId == user.BranchId));
if (filter.IsCompleted.HasValue)
{
var userCompletedChallenges = _context.UserLogs
.AsNoTracking()
.Where(_ => _.UserId == userId && _.ChallengeId.HasValue && !_.IsDeleted)
.Select(_ => _.ChallengeId);
challengeList = challengeList
.Where(_ => userCompletedChallenges.Contains(_.Id) == filter.IsCompleted.Value);
}
var data = await challengeList
.ApplyOrdering(filter)
.ApplyPagination(filter)
.Select(_ => _.Id)
.ToListAsync();
return(new DataWithCount <IEnumerable <int> >()
{
Data = data,
Count = await challengeList.CountAsync()
});
}
public async Task <DataWithCount <IEnumerable <int> > > PageIdsAsync(ChallengeFilter filter,
int userId)
{
var user = await _context.Users.FindAsync(userId);
var challengeList = ApplyFilters(filter)
.Where(_ => (_.LimitToSystemId == null || _.LimitToSystemId == user.SystemId) &&
(_.LimitToBranchId == null || _.LimitToBranchId == user.BranchId) &&
(_.LimitToProgramId == null || _.LimitToProgramId == user.ProgramId));
var data = await challengeList
.Include(_ => _.ChallengeCategories)
.ThenInclude(_ => _.Category)
.OrderBy(_ => _.Name)
.ThenBy(_ => _.Id)
.ApplyPagination(filter)
.Select(_ => _.Id)
.ToListAsync();
return(new DataWithCount <IEnumerable <int> >()
{
Data = data,
Count = await challengeList.CountAsync()
});
}
public static object GetData(this IQueryable <ChallengeTool> query, ChallengeFilter filter, string sort, string[] fields, int page, int limit, int total)
{
query = query.Filter(filter);
query = query.Pagination(page, limit);
var result = query.SelectField(fields, total);
return(result);
}
public object GetDetail(ChallengeFilter filter, string sort, string[] fields, int page, int limit)
{
var query = Get();
int totalPage = 0;
if (limit > -1)
{
totalPage = query.Count() / limit;
}
return(query.GetData(filter, sort, fields, page, limit, totalPage));
}
public async Task <ICollection <Challenge> > PageAllAsync(ChallengeFilter filter)
{
var challengeList = await ApplyFilters(filter)
.ApplyOrdering(filter)
.ApplyPagination(filter)
.ProjectTo <Challenge>(_mapper.ConfigurationProvider)
.ToListAsync();
foreach (var challenge in challengeList)
{
challenge.HasDependents = await HasDependentsAsync(challenge.Id);
}
return(challengeList);
}
PageAllAsync(ChallengeFilter filter)
{
var challengeList = await ApplyFilters(filter)
.OrderBy(_ => _.Name)
.ThenBy(_ => _.Id)
.ApplyPagination(filter)
.ProjectTo <Challenge>()
.ToListAsync();
foreach (var challenge in challengeList)
{
challenge.HasDependents = await HasDependentsAsync(challenge.Id);
}
return(challengeList);
}
GetPaginatedChallengeListAsync(ChallengeFilter filter)
{
ICollection <Challenge> challenges = null;
int challengeCount;
filter.IsActive = true;
filter.SiteId = GetCurrentSiteId();
if (GetAuthUser().Identity.IsAuthenticated)
{
var userLookupChallenges = new List <Challenge>();
int userId = GetActiveUserId();
filter.FavoritesUserId = userId;
var challengeIds = await _challengeRepository.PageIdsAsync(filter, userId);
foreach (var challengeId in challengeIds.Data)
{
var challengeStatus = await _challengeRepository
.GetActiveByIdAsync(challengeId, userId);
int completed = challengeStatus.Tasks.Count(_ => _.IsCompleted == true);
if (completed > 0)
{
challengeStatus.Status = $"Completed {completed} of {challengeStatus.TasksToComplete} tasks.";
challengeStatus.PercentComplete = Math.Min((int)(completed * 100 / challengeStatus.TasksToComplete), 100);
challengeStatus.CompletedTasks = completed;
}
userLookupChallenges.Add(challengeStatus);
}
challenges = userLookupChallenges;
challengeCount = challengeIds.Count;
}
else
{
challenges = await _challengeRepository.PageAllAsync(filter);
challengeCount = await _challengeRepository.GetChallengeCountAsync(filter);
}
await AddBadgeFilenames(challenges);
return(new DataWithCount <IEnumerable <Challenge> >
{
Data = challenges,
Count = challengeCount
});
}
public static IQueryable <T> ApplyOrdering <T>(this IQueryable <T> queryable,
ChallengeFilter filter)
where T : Challenge
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
return(filter.Ordering switch
{
ChallengeFilter.OrderingOption.Name => queryable.OrderBy(_ => _.Name),
ChallengeFilter.OrderingOption.Recent => queryable
.OrderByDescending(_ => _.CreatedAt)
.ThenBy(_ => _.Name),
_ => queryable
.OrderByDescending(_ => _.EstimatedPopularity)
.ThenByDescending(_ => _.CreatedAt)
});
public IActionResult Get([FromQuery] ChallengeFilter filter,
[FromQuery] string sort,
[FromQuery] string[] fields,
[FromQuery] int page = 0,
[FromQuery] int limit = -1)
{
try
{
var domain = _uow.GetService <ChallengeDomain>();
if (fields.Length == 0)
{
fields = new string[] { ChallengeFieldsDetail.INFO };
}
var result = domain.GetDetail(filter, sort, fields, page, limit);
return(Success(result));
}
catch (Exception ex)
{
return(Error(ex.Message));
}
}
public async Task <int> GetChallengeCountAsync(ChallengeFilter filter)
{
return(await ApplyFilters(filter).CountAsync());
}
public async Task <IActionResult> Index(string Search = null,
int?Program = null,
string Categories = null,
string Group = null,
bool Favorites = false,
string Status = null,
int page = 1,
ChallengeFilter.OrderingOption ordering = ChallengeFilter.OrderingOption.MostPopular,
System.Net.HttpStatusCode httpStatus = System.Net.HttpStatusCode.OK)
{
var filter = new ChallengeFilter(page)
{
Ordering = ordering
};
if (!string.IsNullOrWhiteSpace(Search))
{
filter.Search = Search;
}
if (Program.HasValue)
{
filter.ProgramIds = new List <int?> {
Program
};
}
if (!string.IsNullOrWhiteSpace(Categories))
{
var categoryIds = new List <int>();
foreach (var category in Categories.Split(','))
{
if (int.TryParse(category, out int result))
{
categoryIds.Add(result);
}
}
filter.CategoryIds = categoryIds;
}
if (AuthUser.Identity.IsAuthenticated)
{
filter.Favorites = Favorites;
if (string.IsNullOrWhiteSpace(Status) ||
string.Equals(Status, StatusUncompleted, StringComparison.OrdinalIgnoreCase))
{
filter.IsCompleted = false;
}
else if (string.Equals(Status, StatusCompleted,
StringComparison.OrdinalIgnoreCase))
{
filter.IsCompleted = true;
}
}
ChallengeGroup challengeGroup = null;
if (!string.IsNullOrWhiteSpace(Group))
{
challengeGroup = await _challengeService.GetActiveGroupByStubAsync(Group);
if (challengeGroup != null)
{
filter.GroupId = challengeGroup.Id;
}
PageTitle
= _sharedLocalizer[Annotations.Title.ChallengeGroup, challengeGroup.Name];
}
var challengeList = await _challengeService.GetPaginatedChallengeListAsync(filter);
var paginateModel = new PaginateViewModel
{
ItemCount = challengeList.Count,
CurrentPage = page,
ItemsPerPage = filter.Take.Value
};
if (paginateModel.PastMaxPage)
{
return(RedirectToRoute(
new
{
page = paginateModel.LastPage ?? 1
}));
}
foreach (var challenge in challengeList.Data)
{
if (!string.IsNullOrEmpty(challenge.BadgeFilename))
{
challenge.BadgeFilename = _pathResolver
.ResolveContentPath(challenge.BadgeFilename);
}
if (challenge.IsCompleted == true)
{
challenge.Status = _sharedLocalizer[Annotations.Interface.Completed];
}
}
var siteStage = GetSiteStage();
var isActive = siteStage == SiteStage.ProgramOpen ||
siteStage == SiteStage.ProgramEnded;
var categoryList = await _categoryService.GetListAsync(true);
var featuredChallengeGroups = await _challengeService
.GetActiveFeaturedChallengeGroupsAsync();
var viewModel = new ChallengesListViewModel
{
Categories = Categories,
CategoryIds = filter.CategoryIds,
CategoryList = new SelectList(categoryList, "Id", "Name"),
ChallengeGroup = challengeGroup,
Challenges = challengeList.Data.ToList(),
Favorites = Favorites,
FeaturedChallengeGroups = featuredChallengeGroups,
IsActive = isActive,
IsLoggedIn = AuthUser.Identity.IsAuthenticated,
Ordering = filter.Ordering,
PaginateModel = paginateModel,
Program = Program,
ProgramList = new SelectList(await _siteService.GetProgramList(), "Id", "Name"),
Search = Search,
Status = Status
};
if (!string.IsNullOrWhiteSpace(Search))
{
HttpContext.Session.SetString(SessionKey.ChallengeSearch, Search);
}
else
{
HttpContext.Session.Remove(SessionKey.ChallengeSearch);
}
HttpContext.Session.SetInt32(SessionKey.ChallengePage, page);
if (httpStatus != System.Net.HttpStatusCode.OK)
{
Response.StatusCode = (int)httpStatus;
}
return(View(nameof(Index), viewModel));
}
private static IQueryable <Challenge> Filter(this IQueryable <Challenge> query, ChallengeFilter filter)
{
if (filter.Ids != null)
{
query = query.Where(s => filter.Ids.Contains(s.ChallengeId));
}
if (filter.Name != null && filter.Name.Length > 0)
{
query = query.Where(s => s.ChallengeName.Contains(filter.Name));
}
return(query);
}
private async Task <ChallengesListViewModel> GetChallengeList(string Search, string Categories, int?Program,
int?System, int?Branch, bool?Mine, int page = 1, bool pending = false)
{
var filter = new ChallengeFilter(page);
if (!string.IsNullOrWhiteSpace(Search))
{
filter.Search = Search;
}
if (!string.IsNullOrWhiteSpace(Categories))
{
var categoryIds = new List <int>();
foreach (var category in Categories.Split(','))
{
if (int.TryParse(category, out int result))
{
categoryIds.Add(result);
}
}
filter.CategoryIds = categoryIds;
}
if (System.HasValue)
{
filter.SystemIds = new List <int>()
{
System.Value
};
}
if (Branch.HasValue)
{
filter.BranchIds = new List <int>()
{
Branch.Value
};
}
if (Program.HasValue)
{
if (Program.Value == 0)
{
filter.ProgramIds = new List <int?>()
{
null
};
}
else
{
filter.ProgramIds = new List <int?>()
{
Program.Value
};
}
}
if (Mine == true)
{
filter.UserIds = new List <int>()
{
GetId(ClaimType.UserId)
};
}
if (pending)
{
filter.IsActive = false;
}
var challengeList = await _challengeService
.MCGetPaginatedChallengeListAsync(filter);
foreach (var challenge in challengeList.Data)
{
if (!string.IsNullOrEmpty(challenge.BadgeFilename))
{
challenge.BadgeFilename = _pathResolver.ResolveContentPath(challenge.BadgeFilename);
}
}
var paginateModel = new PaginateViewModel
{
ItemCount = challengeList.Count,
CurrentPage = (filter.Skip.Value / filter.Take.Value) + 1,
ItemsPerPage = filter.Take.Value
};
var systemList = (await _siteService.GetSystemList())
.OrderByDescending(_ => _.Id == GetId(ClaimType.SystemId)).ThenBy(_ => _.Name);
var categoryList = await _categoryService.GetListAsync();
var viewModel = new ChallengesListViewModel
{
Challenges = challengeList.Data,
PaginateModel = paginateModel,
Search = filter.Search,
Categories = Categories,
System = System,
Branch = Branch,
Program = Program,
Mine = Mine,
CanAddChallenges = UserHasPermission(Permission.AddChallenges),
CanDeleteChallenges = UserHasPermission(Permission.RemoveChallenges),
CanEditChallenges = UserHasPermission(Permission.EditChallenges),
SystemList = systemList,
ProgramList = await _siteService.GetProgramList(),
CategoryIds = filter.CategoryIds,
CategoryList = new SelectList(categoryList, "Id", "Name")
};
if (Mine == true)
{
viewModel.BranchList = (await _siteService.GetBranches(GetId(ClaimType.SystemId)))
.OrderByDescending(_ => _.Id == GetId(ClaimType.BranchId))
.ThenBy(_ => _.Name);
viewModel.ActiveNav = "Mine";
if (pending && !UserHasPermission(Permission.ActivateAllChallenges))
{
viewModel.SystemName = systemList
.SingleOrDefault(_ => _.Id == GetId(ClaimType.SystemId))?.Name;
}
}
else if (Branch.HasValue)
{
var branch = await _siteService.GetBranchByIdAsync(viewModel.Branch.Value);
viewModel.BranchName = branch.Name;
viewModel.SystemName = systemList
.SingleOrDefault(_ => _.Id == branch.SystemId)?.Name;
viewModel.BranchList = (await _siteService.GetBranches(branch.SystemId))
.OrderByDescending(_ => _.Id == GetId(ClaimType.BranchId))
.ThenBy(_ => _.Name);
viewModel.ActiveNav = "Branch";
}
else if (System.HasValue)
{
viewModel.SystemName = systemList
.SingleOrDefault(_ => _.Id == viewModel.System.Value)?.Name;
viewModel.BranchList = (await _siteService.GetBranches(viewModel.System.Value))
.OrderByDescending(_ => _.Id == GetId(ClaimType.BranchId))
.ThenBy(_ => _.Name);
viewModel.ActiveNav = "System";
}
else
{
viewModel.BranchList = (await _siteService.GetBranches(GetId(ClaimType.SystemId)))
.OrderByDescending(_ => _.Id == GetId(ClaimType.BranchId))
.ThenBy(_ => _.Name);
viewModel.ActiveNav = "All";
}
if (Program.HasValue)
{
if (Program.Value > 0)
{
viewModel.ProgramName =
(await _siteService.GetProgramByIdAsync(Program.Value)).Name;
}
else
{
viewModel.ProgramName = "Not Limited";
}
}
return(viewModel);
}
private IQueryable <Data.Model.Challenge> ApplyFilters(ChallengeFilter filter)
{
var challenges = _context.Challenges.AsNoTracking()
.Where(_ => !_.IsDeleted &&
_.SiteId == filter.SiteId);
if (filter.SystemIds?.Any() == true)
{
challenges = challenges.Where(_ => filter.SystemIds.Contains(_.RelatedSystemId));
}
if (filter.BranchIds?.Any() == true)
{
challenges = challenges.Where(_ => filter.BranchIds.Contains(_.RelatedBranchId));
}
if (filter.ProgramIds?.Any() == true)
{
challenges = challenges
.Where(_ => filter.ProgramIds.Any(p => p == _.AssociatedProgramId));
}
if (filter.UserIds?.Any() == true)
{
challenges = challenges.Where(_ => filter.UserIds.Contains(_.CreatedBy));
}
if (filter.ChallengeIds?.Any() == true)
{
challenges = challenges.Where(_ => !filter.ChallengeIds.Contains(_.Id));
}
if (filter.CategoryIds?.Any() == true)
{
challenges = challenges
.Where(_ => _.ChallengeCategories
.Select(c => c.CategoryId)
.Any(c => filter.CategoryIds.Contains(c)));
}
if (filter.Favorites == true && filter.FavoritesUserId.HasValue)
{
var userFavoriteChallenges = _context.UserFavoriteChallenges
.AsNoTracking()
.Where(_ => _.UserId == filter.FavoritesUserId);
challenges = from challengeList in challenges
join userFavorites in userFavoriteChallenges
on challengeList.Id equals userFavorites.ChallengeId
select challengeList;
}
if (filter.GroupId.HasValue)
{
var challengeGroup = _context.ChallengeGroups
.AsNoTracking()
.Where(_ => _.Id == filter.GroupId)
.SelectMany(_ => _.ChallengeGroupChallenges)
.Select(_ => _.ChallengeId);
challenges = challenges.Where(_ => challengeGroup.Contains(_.Id));
}
if (!string.IsNullOrWhiteSpace(filter.Search))
{
challenges = challenges
.Where(_ => _.Name.Contains(filter.Search) ||
_.Description.Contains(filter.Search) ||
_.Tasks.Any(_t => _t.Title.Contains(filter.Search)) ||
_.Tasks.Any(_t => _t.Author.Contains(filter.Search)) ||
_.ChallengeCategories.Any(c => c.Category.Name.Contains(filter.Search)));
}
if (filter.IsActive.HasValue)
{
challenges = challenges.Where(_ => _.IsActive == filter.IsActive.Value);
}
return(challenges);
}
private static IQueryable <ChallengeTool> Filter(this IQueryable <ChallengeTool> query, ChallengeFilter filter)
{
if (filter.Ids != null)
{
query = query.Where(s => filter.Ids.Contains(s.ChallengeId));
}
return(query);
}
Generate(Site site, int count, int challengePercent, int codePercent, bool quiet)
{
int[] minuteCeilings = { 60, 120, 500 };
float[] minuteCeilingDistribution = { 0.85F, 0.1F, 0.05F };
var userList = await _userService.GetPaginatedUserListAsync(new UserFilter());
var codeList = await _triggerService.GetPaginatedListAsync(new TriggerFilter
{
SecretCodesOnly = true
});
var challengeList = await _challengeService
.GetPaginatedChallengeListAsync(new ChallengeFilter());
var activities = new List <GeneratedActivity>();
var rand = new Bogus.Randomizer();
if (!quiet)
{
Console.Write($"Generating {count} activity items... ");
}
ProgressBar progress = quiet ? null : new ProgressBar();
try
{
for (int i = 0; i < count; i++)
{
bool addActivity = false;
var randomUser = (await _userService.GetPaginatedUserListAsync(new UserFilter
{
SiteId = site.Id,
Skip = rand.Int(0, userList.Count - 1),
Take = 1
})).Data.First();
var act = new GeneratedActivity
{
User = randomUser,
};
if (challengePercent > 0 && rand.Int(1, 100) <= challengePercent)
{
bool isValid = false;
int challengeLookupCount = 0;
await _configureUserSite.Lookup(randomUser.Id);
_challengeService.ClearCachedUserContext();
DataWithCount <IEnumerable <Challenge> > randomChallenge = null;
while (!isValid)
{
challengeLookupCount++;
var filter = new ChallengeFilter()
{
Take = rand.Int(0, challengeList.Count - 1),
Skip = 1
};
randomChallenge = await _challengeService.GetPaginatedChallengeListAsync(filter);
if (randomChallenge.Data != null &&
randomChallenge.Data.FirstOrDefault() != null)
{
isValid = randomChallenge.Data.First().IsValid;
}
if (challengeLookupCount > 20)
{
_logger.LogError($"Unable to find an eligible challenge for user id {randomUser.Id} after 20 tries, giving up.");
randomChallenge = null;
addActivity = false;
break;
}
}
if (randomChallenge != null)
{
var randomTasks = await _challengeService
.GetChallengeTasksAsync(randomChallenge.Data.First().Id);
var randomTask = randomTasks
.Skip(rand.Int(0, randomTasks.Count() - 1)).First();
randomTask.IsCompleted = true;
act.ActivityType = ActivityType.ChallengeTasks;
act.ChallengeId = randomChallenge.Data.First().Id;
act.ChallengeTasks = new List <ChallengeTask> {
randomTask
};
addActivity = true;
}
}
else
{
if (codePercent > 0 && rand.Int(1, 100) <= codePercent)
{
var randomCode = (await _triggerService.GetPaginatedListAsync(new TriggerFilter
{
SiteId = site.Id,
Skip = rand.Int(0, codeList.Count - 1),
Take = 1,
SecretCodesOnly = true
})).Data.First();
act.ActivityType = ActivityType.SecretCode;
act.SecretCode = randomCode.SecretCode;
addActivity = true;
}
else
{
act.ActivityAmount = rand.Int(1, rand
.WeightedRandom <int>(minuteCeilings, minuteCeilingDistribution));
act.ActivityType = ActivityType.Default;
addActivity = true;
}
}
if (addActivity)
{
activities.Add(act);
}
if (progress != null)
{
progress.Report((double)i / count);
}
}
}
finally
{
if (progress != null)
{
progress.Dispose();
Console.WriteLine();
}
}
return(activities);
}
public async Task <IActionResult> GetChallengeList(string challengeIds,
string scope,
string search,
bool showActive = false,
int page = 1)
{
var filter = new ChallengeFilter(page, 10)
{
IsActive = true,
Search = search
};
if (!string.IsNullOrWhiteSpace(challengeIds))
{
filter.ChallengeIds = challengeIds.Split(',')
.Where(_ => !string.IsNullOrWhiteSpace(_))
.Select(int.Parse)
.ToList();
}
switch (scope.ToLower())
{
case ("system"):
filter.SystemIds = new List <int> {
GetId(ClaimType.SystemId)
};
break;
case ("branch"):
filter.BranchIds = new List <int> {
GetId(ClaimType.BranchId)
};
break;
case ("mine"):
filter.UserIds = new List <int> {
GetId(ClaimType.UserId)
};
break;
default:
break;
}
var challengeList = await _challengeService.MCGetPaginatedChallengeListAsync(filter);
var paginateModel = new PaginateViewModel
{
ItemCount = challengeList.Count,
CurrentPage = page,
ItemsPerPage = filter.Take.Value
};
var viewModel = new ChallengesListViewModel
{
Challenges = challengeList.Data,
PaginateModel = paginateModel,
CanEditChallenges = UserHasPermission(Permission.EditChallenges),
ShowActive = showActive
};
foreach (var challenge in viewModel.Challenges)
{
if (!string.IsNullOrWhiteSpace(challenge.BadgeFilename))
{
challenge.BadgeFilename = _pathResolver.ResolveContentPath(
challenge.BadgeFilename);
}
}
return(PartialView("_ChallengeListPartial", viewModel));
}
public async Task <IActionResult> Index(string Search, string Categories, string Group,
bool Favorites = false, int page = 1)
{
int siteId = GetCurrentSiteId();
ChallengeFilter filter = new ChallengeFilter(page);
if (!string.IsNullOrWhiteSpace(Search))
{
filter.Search = Search;
}
if (!string.IsNullOrWhiteSpace(Categories))
{
var categoryIds = new List <int>();
foreach (var category in Categories.Split(','))
{
int result;
if (int.TryParse(category, out result))
{
categoryIds.Add(result);
}
}
filter.CategoryIds = categoryIds;
}
if (Favorites == true && AuthUser.Identity.IsAuthenticated)
{
filter.Favorites = true;
}
ChallengeGroup challengeGroup = null;
if (!string.IsNullOrWhiteSpace(Group))
{
challengeGroup = await _challengeService.GetActiveGroupByStubAsync(Group);
if (challengeGroup != null)
{
filter.GroupId = challengeGroup.Id;
}
}
var challengeList = await _challengeService.GetPaginatedChallengeListAsync(filter);
PaginateViewModel paginateModel = new PaginateViewModel()
{
ItemCount = challengeList.Count,
CurrentPage = page,
ItemsPerPage = filter.Take.Value
};
if (paginateModel.MaxPage > 0 && paginateModel.CurrentPage > paginateModel.MaxPage)
{
return(RedirectToRoute(
new
{
page = paginateModel.LastPage ?? 1
}));
}
foreach (var challenge in challengeList.Data)
{
if (!string.IsNullOrEmpty(challenge.BadgeFilename))
{
challenge.BadgeFilename = _pathResolver.ResolveContentPath(challenge.BadgeFilename);
}
if (challenge.IsCompleted == true)
{
challenge.Status = "Completed!";
}
}
var siteStage = GetSiteStage();
var isActive = (siteStage == SiteStage.ProgramOpen ||
siteStage == SiteStage.ProgramEnded);
var categoryList = await _categoryService.GetListAsync(true);
ChallengesListViewModel viewModel = new ChallengesListViewModel()
{
Challenges = challengeList.Data.ToList(),
ChallengeGroup = challengeGroup,
PaginateModel = paginateModel,
Search = Search,
Categories = Categories,
Favorites = Favorites,
IsActive = isActive,
IsLoggedIn = AuthUser.Identity.IsAuthenticated,
CategoryIds = filter.CategoryIds,
CategoryList = new SelectList(categoryList, "Id", "Name")
};
if (!string.IsNullOrWhiteSpace(Search))
{
HttpContext.Session.SetString(SessionKey.ChallengeSearch, Search);
}
else
{
HttpContext.Session.Remove(SessionKey.ChallengeSearch);
}
HttpContext.Session.SetInt32(SessionKey.ChallengePage, page);
return(View(nameof(Index), viewModel));
}
