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