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> Edit(ChallengesDetailViewModel model, string Submit)
{
var site = await GetCurrentSiteAsync();
if (site.MaxPointsPerChallengeTask.HasValue && model.Challenge.TasksToComplete.HasValue &&
model.Challenge.TasksToComplete != 0)
{
double pointsPerChallenge = (double)model.Challenge.PointsAwarded / model.Challenge.TasksToComplete.Value;
if (pointsPerChallenge > site.MaxPointsPerChallengeTask)
{
ModelState.AddModelError("Challenge.PointsAwarded", $"Too many points awarded.");
}
}
if (model.BadgeUploadImage != null &&
(string.IsNullOrWhiteSpace(model.BadgeMakerImage) || !model.UseBadgeMaker))
{
if (Path.GetExtension(model.BadgeUploadImage.FileName).ToLower() != ".jpg" &&
Path.GetExtension(model.BadgeUploadImage.FileName).ToLower() != ".jpeg" &&
Path.GetExtension(model.BadgeUploadImage.FileName).ToLower() != ".png")
{
ModelState.AddModelError("BadgeUploadImage", "Please use a .jpg or .png image");
}
}
if (ModelState.IsValid)
{
var challenge = model.Challenge;
if (model.BadgeUploadImage != null ||
!string.IsNullOrWhiteSpace(model.BadgeMakerImage))
{
byte[] badgeBytes;
string filename;
if (!string.IsNullOrWhiteSpace(model.BadgeMakerImage) &&
(model.BadgeUploadImage != null || model.UseBadgeMaker))
{
var badgeString = model.BadgeMakerImage.Split(',').Last();
badgeBytes = Convert.FromBase64String(badgeString);
filename = "badge.png";
}
else
{
using (var fileStream = model.BadgeUploadImage.OpenReadStream())
{
using (var ms = new MemoryStream())
{
fileStream.CopyTo(ms);
badgeBytes = ms.ToArray();
}
}
filename = Path.GetFileName(model.BadgeUploadImage.FileName);
}
if (challenge.BadgeId == null)
{
Badge newBadge = new Badge()
{
Filename = filename
};
var badge = await _badgeService.AddBadgeAsync(newBadge, badgeBytes);
challenge.BadgeId = badge.Id;
}
else
{
var existing = await _badgeService
.GetByIdAsync((int)challenge.BadgeId);
existing.Filename = Path.GetFileName(model.BadgePath);
await _badgeService.ReplaceBadgeFileAsync(existing, badgeBytes);
}
}
try
{
var savedChallenge = await _challengeService.EditChallengeAsync(challenge);
AlertSuccess = $"Challenge '<strong>{challenge.Name}</strong>' was successfully modified";
if (Submit == "Activate" &&
(UserHasPermission(Permission.ActivateAllChallenges) ||
(UserHasPermission(Permission.ActivateSystemChallenges) &&
challenge.RelatedSystemId == GetId(ClaimType.SystemId))))
{
if (savedChallenge.IsValid)
{
await _challengeService.ActivateChallengeAsync(savedChallenge);
AlertSuccess = $"Challenge '<strong>{challenge.Name}</strong>' was successfully modified and activated";
}
}
}
catch (GraException gex)
{
ShowAlertWarning("Unable to edit challenge: ", gex.Message);
}
return(RedirectToAction("Edit", new { id = model.Challenge.Id }));
}
else
{
var tasks = await _challengeService.GetChallengeTasksAsync(model.Challenge.Id);
model.Challenge.Tasks = tasks.ToList();
PageTitle = $"Edit Challenge - {model.Challenge.Name}";
model = await GetDetailLists(model);
model.DependentTriggers = await _challengeService
.GetDependentsAsync(model.Challenge.Id);
return(View(model));
}
}
public async Task <IActionResult> Edit(ChallengesDetailViewModel model, string Submit)
{
byte[] badgeBytes = null;
model.IgnorePointLimits = UserHasPermission(Permission.IgnorePointLimits);
model.MaxPointLimit = await _challengeService
.GetMaximumAllowedPointsAsync(GetCurrentSiteId());
if (model.Challenge.TasksToComplete.HasValue &&
model.Challenge.TasksToComplete != 0 &&
model.Challenge.PointsAwarded != 0 &&
!model.IgnorePointLimits)
{
double pointsPerChallenge =
(double)model.Challenge.PointsAwarded / model.Challenge.TasksToComplete.Value;
if (pointsPerChallenge > model.MaxPointLimit)
{
ModelState.AddModelError("Challenge.PointsAwarded",
$"A challenge with {model.Challenge.TasksToComplete} tasks may award a maximum of {model.MaxPointLimit.Value * model.Challenge.TasksToComplete} points.");
}
}
if (model.BadgeUploadImage != null &&
(string.IsNullOrWhiteSpace(model.BadgeMakerImage) || !model.UseBadgeMaker))
{
if (!ValidImageExtensions.Contains(Path
.GetExtension(model.BadgeUploadImage.FileName)
.ToLowerInvariant()))
{
ModelState.AddModelError("BadgeUploadImage", $"Image must be one of the following types: {string.Join(", ", ValidImageExtensions)}");
}
try
{
using (var ms = new MemoryStream())
{
await model.BadgeUploadImage.CopyToAsync(ms);
badgeBytes = ms.ToArray();
}
await _badgeService.ValidateBadgeImageAsync(badgeBytes);
}
catch (GraException gex)
{
ModelState.AddModelError("BadgeUploadImage", gex.Message);
}
}
if (ModelState.IsValid)
{
var challenge = model.Challenge;
if (model.BadgeUploadImage != null ||
!string.IsNullOrWhiteSpace(model.BadgeMakerImage))
{
string filename;
if (!string.IsNullOrWhiteSpace(model.BadgeMakerImage) &&
(model.BadgeUploadImage == null || model.UseBadgeMaker))
{
var badgeString = model.BadgeMakerImage.Split(',').Last();
badgeBytes = Convert.FromBase64String(badgeString);
filename = "badge.png";
}
else
{
if (badgeBytes == null)
{
using (var ms = new MemoryStream())
{
await model.BadgeUploadImage.CopyToAsync(ms);
badgeBytes = ms.ToArray();
}
}
filename = Path.GetFileName(model.BadgeUploadImage.FileName);
}
if (challenge.BadgeId == null)
{
var newBadge = new Badge
{
Filename = filename
};
var badge = await _badgeService.AddBadgeAsync(newBadge, badgeBytes);
challenge.BadgeId = badge.Id;
}
else
{
var existing = await _badgeService
.GetByIdAsync((int)challenge.BadgeId);
existing.Filename = Path.GetFileName(model.BadgePath);
await _badgeService.ReplaceBadgeFileAsync(existing,
badgeBytes,
model.BadgeUploadImage.FileName);
}
}
try
{
var serviceResult = await _challengeService.EditChallengeAsync(challenge);
if (serviceResult.Status == ServiceResultStatus.Warning &&
!string.IsNullOrWhiteSpace(serviceResult.Message))
{
ShowAlertWarning(serviceResult.Message);
}
AlertSuccess = $"Challenge '<strong>{challenge.Name}</strong>' was successfully modified";
var hasPermissions = UserHasPermission(Permission.ActivateAllChallenges) ||
UserHasPermission(Permission.ActivateSystemChallenges);
if (Submit == "Activate" &&
hasPermissions &&
challenge.RelatedSystemId == GetId(ClaimType.SystemId) &&
serviceResult.Data.IsValid)
{
await _challengeService.ActivateChallengeAsync(serviceResult.Data);
AlertSuccess = $"Challenge '<strong>{challenge.Name}</strong>' was successfully modified and activated";
}
}
catch (GraException gex)
{
ShowAlertWarning("Unable to edit challenge: ", gex.Message);
}
return(RedirectToAction("Edit", new { id = model.Challenge.Id }));
}
else
{
var tasks = await _challengeService.GetChallengeTasksAsync(model.Challenge.Id);
model.Challenge.Tasks = tasks.ToList();
PageTitle = $"Edit Challenge - {model.Challenge.Name}";
model = await GetDetailLists(model);
model.DependentTriggers = await _challengeService
.GetDependentsAsync(model.Challenge.Id);
model.Groups = await _challengeService.GetGroupsByChallengeId(model.Challenge.Id);
model.RelatedEvents = await _eventService.GetByChallengeIdAsync(model.Challenge.Id);
if (model.MaxPointLimit.HasValue)
{
model.MaxPointsMessage = $"(Up to {model.MaxPointLimit.Value} points per required task)";
var currentChallenge = await _challengeService
.MCGetChallengeDetailsAsync(model.Challenge.Id);
if (currentChallenge.TasksToComplete.HasValue)
{
double pointsPerChallenge = (double)currentChallenge.PointsAwarded
/ currentChallenge.TasksToComplete.Value;
if (pointsPerChallenge > model.MaxPointLimit.Value)
{
model.MaxPointsWarningMessage = $"This Challenge exceeds the maximum of {model.MaxPointLimit.Value} points per required task - only Administrators can edit it.";
}
}
}
return(View(model));
}
}
