public IActionResult OpenModifyTask(ChallengesDetailViewModel viewModel, int taskId)
{
TempData[EditTask] = taskId;
TempData[TempEditChallenge] = Newtonsoft.Json.JsonConvert
.SerializeObject(viewModel.Challenge);
return(RedirectToAction("Edit", new { id = viewModel.Challenge.Id }));
}
public async Task <IActionResult> Create()
{
var site = await GetCurrentSiteAsync();
var siteUrl = await _siteService.GetBaseUrl(Request.Scheme, Request.Host.Value);
PageTitle = "Create Challenge";
var viewModel = new ChallengesDetailViewModel
{
BadgeMakerUrl = GetBadgeMakerUrl(siteUrl, site.FromEmailAddress),
UseBadgeMaker = true,
IgnorePointLimits = UserHasPermission(Permission.IgnorePointLimits),
MaxPointLimit = await _challengeService.GetMaximumAllowedPointsAsync(site.Id)
};
viewModel = await GetDetailLists(viewModel);
if (viewModel.MaxPointLimit.HasValue)
{
viewModel.MaxPointsMessage = $"(Up to {viewModel.MaxPointLimit.Value} points per required task)";
}
return(View(viewModel));
}
private async Task <ChallengesDetailViewModel> GetDetailLists(ChallengesDetailViewModel model)
{
var systemList = (await _siteService.GetSystemList())
.OrderByDescending(_ => _.Id == GetId(ClaimType.SystemId))
.ThenBy(_ => _.Name);
model.SystemList = new SelectList(systemList, "Id", "Name");
var programList = (await _siteService.GetProgramList());
model.ProgramList = new SelectList(programList, "Id", "Name");
if (model.Challenge?.LimitToSystemId.HasValue == true)
{
var branchList = (await _siteService
.GetBranches(model.Challenge.LimitToSystemId.Value))
.OrderByDescending(_ => _.Id == GetId(ClaimType.BranchId))
.ThenBy(_ => _.Name);
model.BranchList = new SelectList(branchList, "Id", "Name");
}
else
{
var branchList = (await _siteService.GetAllBranches())
.OrderByDescending(_ => _.Id == GetId(ClaimType.BranchId))
.ThenBy(_ => _.Name);
model.BranchList = new SelectList(branchList, "Id", "Name");
}
return(model);
}
public async Task <IActionResult> ModifyTask(ChallengesDetailViewModel viewModel)
{
foreach (string key in ModelState.Keys.Where(m => m.StartsWith("Challenge.")).ToList())
{
ModelState.Remove(key);
}
if (ModelState.IsValid)
{
if (viewModel.Task.ChallengeTaskType == ChallengeTaskType.Action)
{
viewModel.Task.Author = null;
viewModel.Task.Isbn = null;
viewModel.Task.Url = null;
}
await _challengeService.EditTaskAsync(viewModel.Task);
}
else
{
TempData[EditTask] = viewModel.Task.Id;
}
TempData[TempEditChallenge] = Newtonsoft.Json.JsonConvert
.SerializeObject(viewModel.Challenge);
return(RedirectToAction("Edit", new { id = viewModel.Challenge.Id }));
}
public async Task <IActionResult> DeleteTask(ChallengesDetailViewModel viewModel, int id)
{
await _challengeService.RemoveTaskAsync(id);
TempData[TempEditChallenge] = Newtonsoft.Json.JsonConvert
.SerializeObject(viewModel.Challenge);
return(RedirectToAction("Edit", new { id = viewModel.Challenge.Id }));
}
IncreaseTaskSort(ChallengesDetailViewModel viewModel, int id)
{
await _challengeService.IncreaseTaskPositionAsync(id);
TempData[TempEditChallenge] = Newtonsoft.Json.JsonConvert
.SerializeObject(viewModel.Challenge);
return(RedirectToAction("Edit", new { id = viewModel.Challenge.Id }));
}
public async Task <IActionResult> DeleteTask(ChallengesDetailViewModel viewModel, int id)
{
try
{
await _challengeService.RemoveTaskAsync(id);
}
catch (GraException gex)
{
ShowAlertDanger("Unable to delete task: ", gex);
}
TempData[TempEditChallenge] = Newtonsoft.Json.JsonConvert
.SerializeObject(viewModel.Challenge);
return(RedirectToAction("Edit", new { id = viewModel.Challenge.Id }));
}
public async Task <IActionResult> AddTask(ChallengesDetailViewModel viewModel)
{
foreach (string key in ModelState.Keys.Where(m => m.StartsWith("Challenge.")).ToList())
{
ModelState.Remove(key);
}
if (ModelState.IsValid)
{
viewModel.Task.ChallengeId = viewModel.Challenge.Id;
await _challengeService.AddTaskAsync(viewModel.Task);
}
else
{
TempData[NewTask] = true;
}
TempData[TempEditChallenge] = Newtonsoft.Json.JsonConvert
.SerializeObject(viewModel.Challenge);
return(RedirectToAction("Edit", new { id = viewModel.Challenge.Id }));
}
public async Task <IActionResult> Create()
{
var site = await GetCurrentSiteAsync();
var siteUrl = await _siteService.GetBaseUrl(Request.Scheme, Request.Host.Value);
PageTitle = "Create Challenge";
ChallengesDetailViewModel viewModel = new ChallengesDetailViewModel()
{
BadgeMakerUrl = GetBadgeMakerUrl(siteUrl, site.FromEmailAddress),
UseBadgeMaker = true
};
viewModel = await GetDetailLists(viewModel);
if (site.MaxPointsPerChallengeTask.HasValue)
{
viewModel.MaxPointsMessage = $"(Up to {site.MaxPointsPerChallengeTask.Value} points per required task)";
}
return(View(viewModel));
}
public IActionResult CloseTask(ChallengesDetailViewModel viewModel)
{
TempData[TempEditChallenge] = Newtonsoft.Json.JsonConvert
.SerializeObject(viewModel.Challenge);
return(RedirectToAction("Edit", new { id = viewModel.Challenge.Id }));
}
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(int id)
{
var site = await GetCurrentSiteAsync();
var siteUrl = await _siteService.GetBaseUrl(Request.Scheme, Request.Host.Value);
Challenge challenge = new Challenge();
try
{
challenge = await _challengeService.MCGetChallengeDetailsAsync(id);
if (TempData.ContainsKey(TempEditChallenge))
{
var storedChallenge = Newtonsoft.Json.JsonConvert
.DeserializeObject <Challenge>((string)TempData[TempEditChallenge]);
challenge.Name = storedChallenge.Name;
challenge.Description = storedChallenge.Description;
challenge.PointsAwarded = storedChallenge.PointsAwarded;
challenge.TasksToComplete = storedChallenge.TasksToComplete;
challenge.LimitToSystemId = storedChallenge.LimitToSystemId;
challenge.LimitToBranchId = storedChallenge.LimitToBranchId;
challenge.LimitToProgramId = storedChallenge.LimitToProgramId;
}
}
catch (GraException gex)
{
ShowAlertWarning("Unable to view challenge: ", gex);
return(RedirectToAction("Index"));
}
if (challenge.TasksToComplete > challenge.Tasks.Count())
{
AlertInfo = "The challenge does not have enough tasks to be completable";
}
bool canActivate = challenge.IsValid &&
!challenge.IsActive &&
(UserHasPermission(Permission.ActivateAllChallenges) ||
(UserHasPermission(Permission.ActivateSystemChallenges) &&
challenge.RelatedSystemId == GetId(ClaimType.SystemId)));
ChallengesDetailViewModel viewModel = new ChallengesDetailViewModel()
{
Challenge = challenge,
TaskTypes = Enum.GetNames(typeof(ChallengeTaskType))
.Select(m => new SelectListItem {
Text = m, Value = m
}).ToList(),
CanActivate = canActivate,
CanViewTriggers = UserHasPermission(Permission.ManageTriggers),
DependentTriggers = await _challengeService.GetDependentsAsync(challenge.Id),
BadgeMakerUrl = GetBadgeMakerUrl(siteUrl, site.FromEmailAddress),
UseBadgeMaker = true
};
if (site.MaxPointsPerChallengeTask.HasValue)
{
viewModel.MaxPointsMessage = $"(Up to {site.MaxPointsPerChallengeTask.Value} points per required task)";
}
if (challenge.BadgeId != null)
{
var challengeBadge = await _badgeService.GetByIdAsync((int)challenge.BadgeId);
if (challengeBadge != null)
{
viewModel.BadgePath = _pathResolver.ResolveContentPath(challengeBadge.Filename);
}
}
if (TempData.ContainsKey(NewTask))
{
TempData.Remove(NewTask);
TempData.Remove(EditTask);
viewModel.AddTask = true;
}
else if (TempData.ContainsKey(EditTask))
{
viewModel.Task = await _challengeService
.GetTaskAsync((int)TempData[EditTask]);
}
PageTitle = $"Edit Challenge - {viewModel.Challenge.Name}";
viewModel = await GetDetailLists(viewModel);
return(View("Edit", viewModel));
}
public async Task <IActionResult> ModifyTask(ChallengesDetailViewModel viewModel)
{
if (!string.IsNullOrWhiteSpace(viewModel.Task.Url))
{
try
{
viewModel.Task.Url = new UriBuilder(
viewModel.Task.Url).Uri.AbsoluteUri;
}
catch (Exception)
{
ShowAlertDanger("Invalid URL");
return(RedirectToAction("Edit", new { id = viewModel.Challenge.Id }));
}
}
foreach (string key in ModelState
.Keys
.Where(m => m.StartsWith("Challenge.", StringComparison.OrdinalIgnoreCase))
.ToList())
{
ModelState.Remove(key);
}
if (viewModel.TaskUploadFile != null &&
!ValidUploadExtensions.Contains(Path
.GetExtension(viewModel.TaskUploadFile.FileName)
.ToLowerInvariant()))
{
ModelState.AddModelError("BadgeUploadImage", $"File upload must be one of the following types: {string.Join(", ", ValidUploadExtensions)}");
}
if (ModelState.IsValid)
{
byte[] fileBytes = null;
if (viewModel.Task.ChallengeTaskType == ChallengeTaskType.Action)
{
viewModel.Task.Author = null;
viewModel.Task.Isbn = null;
}
if (viewModel.TaskUploadFile != null)
{
viewModel.Task.Filename = viewModel.TaskUploadFile.FileName;
using (var fileStream = viewModel.TaskUploadFile.OpenReadStream())
{
using (var ms = new MemoryStream())
{
fileStream.CopyTo(ms);
fileBytes = ms.ToArray();
}
}
}
await _challengeService.EditTaskAsync(viewModel.Task, fileBytes);
}
else
{
TempData[EditTask] = viewModel.Task.Id;
}
TempData[TempEditChallenge] = Newtonsoft.Json.JsonConvert
.SerializeObject(viewModel.Challenge);
return(RedirectToAction("Edit", new { id = viewModel.Challenge.Id }));
}
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));
}
}
public async Task <IActionResult> Edit(int id)
{
var site = await GetCurrentSiteAsync();
var siteUrl = await _siteService.GetBaseUrl(Request.Scheme, Request.Host.Value);
Challenge challenge;
try
{
challenge = await _challengeService.MCGetChallengeDetailsAsync(id);
foreach (var task in challenge.Tasks)
{
if (task.ChallengeTaskType == ChallengeTaskType.Action)
{
task.Description = CommonMark.CommonMarkConverter.Convert(task.Title);
}
if (!string.IsNullOrWhiteSpace(task.Filename))
{
var contentPath = _pathResolver.ResolveContentPath(task.Filename);
task.Filename = $"{siteUrl}/{contentPath}";
}
}
if (TempData.ContainsKey(TempEditChallenge))
{
var storedChallenge = Newtonsoft.Json.JsonConvert
.DeserializeObject <Challenge>((string)TempData[TempEditChallenge]);
challenge.Name = storedChallenge.Name;
challenge.Description = storedChallenge.Description;
challenge.PointsAwarded = storedChallenge.PointsAwarded;
challenge.TasksToComplete = storedChallenge.TasksToComplete;
challenge.LimitToSystemId = storedChallenge.LimitToSystemId;
challenge.LimitToBranchId = storedChallenge.LimitToBranchId;
challenge.AssociatedProgramId = storedChallenge.AssociatedProgramId;
challenge.CategoryIds = storedChallenge.CategoryIds;
}
else
{
challenge.CategoryIds = challenge.Categories.Select(_ => _.Id).ToList();
}
}
catch (GraException gex)
{
ShowAlertWarning("Unable to view challenge: ", gex);
return(RedirectToAction("Index"));
}
if (challenge.TasksToComplete > challenge.Tasks.Count())
{
AlertInfo = "The challenge does not have enough tasks to be completable";
}
bool canActivate = challenge.IsValid &&
!challenge.IsActive &&
(UserHasPermission(Permission.ActivateAllChallenges) ||
(UserHasPermission(Permission.ActivateSystemChallenges) &&
challenge.RelatedSystemId == GetId(ClaimType.SystemId)));
var viewModel = new ChallengesDetailViewModel
{
Challenge = challenge,
CanActivate = canActivate,
CanEditGroups = UserHasPermission(Permission.EditChallengeGroups),
CanManageEvents = UserHasPermission(Permission.ManageEvents),
CanViewParticipants = UserHasPermission(Permission.ViewParticipantDetails),
CanViewTriggers = UserHasPermission(Permission.ManageTriggers),
CreatedByName = await _userService.GetUsersNameByIdAsync(challenge.CreatedBy),
DependentTriggers = await _challengeService.GetDependentsAsync(challenge.Id),
Groups = await _challengeService.GetGroupsByChallengeId(challenge.Id),
RelatedEvents = await _eventService.GetByChallengeIdAsync(challenge.Id),
BadgeMakerUrl = GetBadgeMakerUrl(siteUrl, site.FromEmailAddress),
UseBadgeMaker = true,
IgnorePointLimits = UserHasPermission(Permission.IgnorePointLimits),
MaxPointLimit = await _challengeService.GetMaximumAllowedPointsAsync(site.Id)
};
if (viewModel.MaxPointLimit.HasValue)
{
viewModel.MaxPointsMessage = $"(Up to {viewModel.MaxPointLimit.Value} points per required task)";
}
if (challenge.TasksToComplete.HasValue &&
viewModel.MaxPointLimit.HasValue)
{
double pointsPerChallenge = (double)viewModel.Challenge.PointsAwarded
/ viewModel.Challenge.TasksToComplete.Value;
if (pointsPerChallenge > viewModel.MaxPointLimit)
{
viewModel.MaxPointsWarningMessage = $"This Challenge exceeds the maximum of {viewModel.MaxPointLimit.Value} points per required task - only Administrators can edit it.";
}
}
if (challenge.BadgeId != null)
{
var challengeBadge = await _badgeService.GetByIdAsync((int)challenge.BadgeId);
if (challengeBadge != null)
{
viewModel.BadgePath = _pathResolver.ResolveContentPath(challengeBadge.Filename);
}
}
if (TempData.ContainsKey(NewTask))
{
TempData.Remove(NewTask);
TempData.Remove(EditTask);
viewModel.AddTask = true;
}
else if (TempData.ContainsKey(EditTask))
{
viewModel.Task = await _challengeService
.GetTaskAsync((int)TempData[EditTask]);
if (!string.IsNullOrWhiteSpace(viewModel.Task.Filename))
{
var contentPath = _pathResolver.ResolveContentPath(viewModel.Task.Filename);
viewModel.TaskFilePath = $"{siteUrl}/{contentPath}";
}
}
PageTitle = $"Edit Challenge - {viewModel.Challenge.Name}";
viewModel = await GetDetailLists(viewModel);
return(View("Edit", viewModel));
}
public async Task <IActionResult> Create(ChallengesDetailViewModel model)
{
byte[] badgeBytes = null;
model.IgnorePointLimits = UserHasPermission(Permission.IgnorePointLimits);
model.MaxPointLimit = await _challengeService
.GetMaximumAllowedPointsAsync(GetCurrentSiteId());
if (!model.IgnorePointLimits &&
model.Challenge.TasksToComplete.HasValue &&
model.Challenge.TasksToComplete != 0)
{
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 * 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)
{
try
{
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);
}
var newBadge = new Badge
{
Filename = filename
};
var badge = await _badgeService.AddBadgeAsync(newBadge, badgeBytes);
challenge.BadgeId = badge.Id;
}
var serviceResult = await _challengeService.AddChallengeAsync(challenge);
if (serviceResult.Status == ServiceResultStatus.Warning &&
!string.IsNullOrWhiteSpace(serviceResult.Message))
{
ShowAlertWarning(serviceResult.Message);
}
AlertSuccess = $"Challenge '<strong>{serviceResult.Data.Name}</strong>' was successfully created";
return(RedirectToAction("Edit", new { id = serviceResult.Data.Id }));
}
catch (GraException gex)
{
ShowAlertWarning("Unable to add challenge: ", gex.Message);
}
}
PageTitle = "Create Challenge";
model = await GetDetailLists(model);
if (model.MaxPointLimit.HasValue)
{
model.MaxPointsMessage = $"(Up to {model.MaxPointLimit.Value} points per required task)";
}
return(View(model));
}
public async Task <IActionResult> Create(ChallengesDetailViewModel model)
{
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)
{
try
{
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);
}
Badge newBadge = new Badge()
{
Filename = filename
};
var badge = await _badgeService.AddBadgeAsync(newBadge, badgeBytes);
challenge.BadgeId = badge.Id;
}
challenge = await _challengeService.AddChallengeAsync(challenge);
AlertSuccess = $"Challenge '<strong>{challenge.Name}</strong>' was successfully created";
return(RedirectToAction("Edit", new { id = challenge.Id }));
}
catch (GraException gex)
{
ShowAlertWarning("Unable to add challenge: ", gex.Message);
}
}
PageTitle = "Create Challenge";
model = await GetDetailLists(model);
return(View(model));
}
public async Task <IActionResult> AddTask(ChallengesDetailViewModel viewModel)
{
if (!string.IsNullOrWhiteSpace(viewModel.Task.Url))
{
try
{
viewModel.Task.Url = new UriBuilder(
viewModel.Task.Url).Uri.AbsoluteUri;
}
catch (Exception)
{
ShowAlertDanger("Invalid URL");
return(RedirectToAction("Edit", new { id = viewModel.Challenge.Id }));
}
}
foreach (string key in ModelState.Keys.Where(m => m.StartsWith("Challenge.")).ToList())
{
ModelState.Remove(key);
}
if (viewModel.TaskUploadFile != null)
{
if (Path.GetExtension(viewModel.TaskUploadFile.FileName).ToLower() != ".jpg" &&
Path.GetExtension(viewModel.TaskUploadFile.FileName).ToLower() != ".jpeg" &&
Path.GetExtension(viewModel.TaskUploadFile.FileName).ToLower() != ".png" &&
Path.GetExtension(viewModel.TaskUploadFile.FileName).ToLower() != ".pdf")
{
ModelState.AddModelError("BadgeUploadImage", "Only .jpg, .png and .pdf files are allowed.");
}
}
if (ModelState.IsValid)
{
byte[] fileBytes = null;
if (viewModel.Task.ChallengeTaskType == ChallengeTaskType.Action)
{
viewModel.Task.Author = null;
viewModel.Task.Isbn = null;
viewModel.Task.Url = null;
}
if (viewModel.TaskUploadFile != null)
{
viewModel.Task.Filename = viewModel.TaskUploadFile.FileName;
using (var fileStream = viewModel.TaskUploadFile.OpenReadStream())
{
using (var ms = new MemoryStream())
{
fileStream.CopyTo(ms);
fileBytes = ms.ToArray();
}
}
}
viewModel.Task.ChallengeId = viewModel.Challenge.Id;
await _challengeService.AddTaskAsync(viewModel.Task, fileBytes);
}
else
{
TempData[NewTask] = true;
}
TempData[TempEditChallenge] = Newtonsoft.Json.JsonConvert
.SerializeObject(viewModel.Challenge);
return(RedirectToAction("Edit", new { id = viewModel.Challenge.Id }));
}
